前端面试题总结(转载)

  • DOM结构 —— 两个节点之间可能存在哪些关系以及如何在节点之间任意移动
    
  •  1.DOM中两个节点存在的关系无非3种:
        1.1.包含与被包含,IE率先引入的contains()方法可检测,例 A.contains(B),
              即检查节点B是否是节点A的子节点,返回布尔值,现大多数浏览器都支持;
              DOM level 3引入的compareDocumentPosition(),确定节点之间的关系,
              返回值为一个表示关系的位掩码的合(或者是按位或的值,并不知道具体实现),
              通过按位与操作符“&”可确定关系。例:节点A(例:<html>)在节点B(例:<body>)前--位掩码为4,
              且节点A包含节点B--位掩码为16,则返回值为20,通过"!!(20&16)"这种方式即可返回一个布尔值,
              解析:“20&16”返回16证明节点A包含节点B(即:16),通过!!取得16的布尔值true。
        1.2父与子
            获取父节点:node.parentNode, node.parentElement,两者的区别在于后者只能获取元素;
            获取子节点:childNodes(以NodeList对象存在的子节点集合),firstChild,lastChild
        1.3同辈(兄弟节点)
            nextSiblingpreviousSibling  
        1.4Element Travel APIDOM添加的属性
            childElementCount,firstElementChild,lastElementChild,nextElementSiblingpreviousElementSibling  ,他们与之前的方法之间的区别是多了Element,保证只返回元素节点,而之前的方法普通的文本节点及注释节点也会返回,之前的方法在非IE浏览器中还会把元素间的空白符当文本节点返回。
        1.5children属性(IE9以后)
            与childNodes不同的地方在于:children只包含元素子节点(IE8及之前的版本可能会包含注释节点)

    • DOM操作 —— 如何添加、移除、移动、复制、创建和查找节点等。
    1)创建新节点

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

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

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

    (2)添加、移除、替换、插入

          appendChild()

          removeChild()

          replaceChild()

          insertBefore()

    (3)查找

          getElementsByTagName()    //通过标签名称

          getElementsByName()    //通过元素的Name属性的值

          getElementById()    //通过元素Id,唯一性

     

     

    1.创建元素节点
    document.createElement() 方法 用于创建元素,接受一个参数,即要创建元素的标签名,返回创建的元素节点

    1 var div = document.createElement("div"); //创建一个div元素
    2 div.id = "myDiv"; //设置div的id
    3 div.className = "box"; //设置div的class

    创建元素后还要把元素添加到文档树中

    2.添加元素节点
    appendChild() 方法 用于向childNodes列表的末尾添加一个节点,返回要添加的元素节点

    1 var ul = document.getElementById("myList"); //获得ul
    2 var li = document.createElement("li"); //创建li
    3 li.innerHTML = "项目四"; //向li内添加文本
    4 ul.appendChild(li); //把li 添加到ul子节点的末尾

     


    appendChild() 方法还可以添加已经存在的元素,会将元素从原来的位置移到新的位置
    1 var ul = document.getElementById("myList"); //获得ul
    2 ul.appendChild(ul.firstChild); //把ul的第一个元素节点移到ul子节点的末尾

     

    insertBefore() 方法,如果不是在末尾插入节点,而是想放在特定的位置上,用这个方法,该方法接受2个参数,第一个是要插入的节点,第二个是参照节点,返回要添加的元素节点

    1 var ul = document.getElementById("myList"); //获得ul
    2 var li = document.createElement("li"); //创建li
    3 li.innerHTML= "项目四"; //向li内添加文本
    4 ul.insertBefore(li,ul.firstChild); //把li添加到ul的第一个子节点前
     
    1 var ul = document.getElementById("myList"); //获得ul
    2 var li = document.createElement("li"); //创建li
    3 li.innerHTML= "项目四"; //向li内添加文本
    4 ul.insertBefore(li,ul.lastChild); //把li添加到ul的最后一个子节点(包括文本节点)之前
     
    1 var ul = document.getElementById("myList"); //获得ul
    2 var li = document.createElement("li"); //创建li
    3 li.innerHTML= "项目四"; //向li内添加文本
    4 var lis = ul.getElementsByTagName("li") //获取ul中所有li的集合
    5 ul.insertBefore(li,lis[1]);     //把li添加到ul中的第二个li节点前

    3.移除元素节点
    removeChild() 方法,用于移除节点,接受一个参数,即要移除的节点,返回被移除的节点,注意被移除的节点仍然在文档中,不过文档中已没有其位置了

    1 var ul = document.getElementById("myList"); //获得ul
    2 var fromFirstChild = ul.removeChild(ul.firstChild); //移除ul第一个子节点
     
    1 var ul = document.getElementById("myList"); //获得ul
    2 var lis = ul.getElementsByTagName("li") //获取ul中所有li的集合
    3 ul.removeChild(lis[0]);       //移除第一个li,与上面不同,要考虑浏览器之间的差异

    4.替换元素节点
    replaceChild() 方法,用于替换节点,接受两个参数,第一参数是要插入的节点,第二个是要替换的节点,返回被替换的节点

    1 var ul = document.getElementById("myList"); //获得ul
    2 var fromFirstChild = ul.replaceChild(ul.firstChild); //替换ul第一个子节点
     
    1 var ul = document.getElementById("myList"); //获得ul;
    2 var li = document.createElement("li"); //创建li
    3 li.innerHTML= "项目四"; //向li内添加文本
    4 var lis = ul.getElementsByTagName("li") //获取ul中所有li的集合
    5 var returnNode = ul.replaceChild(li,lis[1]); //用创建的li替换原来的第二个li

    5.复制节点
    cloneNode() 方法,用于复制节点, 接受一个布尔值参数, true 表示深复制(复制节点及其所有子节点), false 表示浅复制(复制节点本身,不复制子节点)

    1 var ul = document.getElementById("myList"); //获得ul
    2 var deepList = ul.cloneNode(true); //深复制
    3 var shallowList = ul.cloneNode(false); //浅复制


  • 事件 —— 如何使用事件,以及IE和标准DOM事件模型之间存在的差别。

    在浏览器解析事件的时候,有两种触发方式,一种叫做Bubbling(冒泡),另外一种叫做Capturing(捕获)。由上图可以看出来,冒泡的方式效果就是当一个DOM元素的某事件例如click事件被fire时,依次它的父元素的click事件也被fire(触发),一直传递到最顶层的body元素为止。而捕获的触发方式正好相反,当某个元素的click事件被触发时,先从最顶层的body元素click事件被触发开始,一直传递到真正被触发的元素为止。

    ****************************************************************************

     

    这次我将讨论W3C的标准DOM事件模型和IE独立门户的DOM事件模型到底有多少区别,首先我们可以回想一下目前大多数Js程序员习惯如何绑定事件到DOM元素上,最常见的就是obj.οnclick=handler这种方式(更恶劣的是在Html代码的元素标签中直接加上onclick属性,完全没达到视图和动作分开的原则)。我们暂时称这种方式的事件添加为Traditional(传统方式)吧,IE有自己的IE Event Module,而火狐等浏览器则遵循的W3C方式的Event Module,下面看看这三者各自的优缺点在哪里——

     

    1、Traditional Module

    传统方式的事件模型即直接在DOM元素上绑定事件处理器,例如—

    window.οnlοad=function(){…}

    obj.οnmοuseοver=function(e){…}

    obj.οnclick=function(){…}

     

    首先这种方式是无论在IE还是Firefox等其他浏览器上都可以成功运行的通用方式。这便是它最大的优势了,而且在Event处理函数内部的this变量无一例外的都只想被绑定的DOM元素,这使得Js程序员可以大大利用this关键字做很多事情。

     

    至于它的缺点也很明显,就是传统方式只支持Bubbling,而不支持Capturing,并且一次只能绑定一个事件处理器在DOM元素上,无法实现多Handler绑定。最后就是function参数中的event参数只对非IE浏览器有效果(因为IE浏览器有特制的window.event)。

     

    2、W3C (Firefox.e.g) EventModule

    Firefox等浏览器很坚决的遵循W3C标准来制定浏览器事件模型,使用addEventListener和removeEventListener两个函数,看几个例子—

    window.addEventListener(‘load’,function(){…},false);

    document.body.addEventListener(‘keypress’,function{…},false);

    obj.addEventListener(‘mouseover’,MV,true);

    function MV(){…}

     

    addEventListener带有三个参数,第一个参数是事件类型,就是我们熟知的那些事件名字去掉前面的’on’,第二个参数是处理函数,可以直接给函数字面量或者函数名,第三个参数是boolean值,表示事件是否支持Capturing。

     

    W3C的事件模型优点是Bubbling和Capturing都支持,并且可以在一个DOM元素上绑定多个事件处理器,各自并不会冲突。并且在处理函数内部,this关键字仍然可以使用只想被绑定的DOM元素。另外function参数列表的第一个位置(不管是否显示调用),都永远是event对象的引用。

     

    至于它的缺点,很不幸的就只有在市场份额最大的IE浏览器下不可使用这一点。

     

    3、IE Event Module

    IE自己的事件模型跟W3C的类似,但主要是通过attachEvent和detachEvent两个函数来实现的。依旧看几个例子吧—

    window.attachEvent(‘onload’,function(){…});

    document.body.attachEvent(‘onkeypress’,myKeyHandler);

     

    可以发现它跟W3C的区别是没有第三个参数,而且第一个表示事件类型的参数也必须把’on’给加上。这种方式的优点就是能绑定多个事件处理函数在同一个DOM元素上。

     

    至于它的缺点,为什么如今在实际开发中很少见呢?首先IE浏览器本身只支持Bubbling不支持Capturing;而且在事件处理的function内部this关键字也无法使用,因为this永远都只想window object这个全局对象。要想得到event对象必须通过window.event方式,最后一点,在别的浏览器中,它显然是无法工作的。

     

    最后我在推荐两个必须知道的IE和W3C标准的区别用法吧—

    1、当我们需要阻止浏览器某DOM元素的默认行为的时候在W3C下调用e.preventDefault(),而在IE下则通过window.event.returnValue=false来实现。

    2、当我们要阻止事件冒泡的时候,在W3C标准里调用e.stopPropagation(),而在IE下通过设置window.event.cancelBubble=true来实现。

  • XMLHttpRequest —— 这是什么、怎样完整地执行一次GET请求、怎样检测错误。
    XMLHttpRequest 对象提供了在网页加载后与服务器进行通信的方法。这是AJAX事件的一个名称,缩写为XHR,是使用XML进行WEB服务器数据交互的一种方式。执行一次get请求有两种方式,以后总是原生JS,一种是JQ封装好的方法。使用JQ的话,$.get();检测错误可以使用error事件然后打印出错误码


  • 严格模式与混杂模式 —— 如何触发这两种模式,区分它们有何意义。

    Doctype:(Document Type)文档类型,它位于文档中最前面的位置,处于标签之前。如果你想制作符合标准的页面,一个必不可少的关键组成部分就是DOCTYPE的声明。确定了正确的Doctype,xhtml里面的标识和css才能正常生效(也就是说它会很负责地告诉浏览器怎么解释你的这个标签和你写的css)。既然它是一种声明,它的责任就是告诉浏览器文档使用哪种html或者xhtml规范。为了获取正确的Doctype声明,关键就是让dtd与文档所遵循的标准对应。例如:假定文档遵循的是xhtml 1.0 strict,那么文档的Doctype声明就应该是相应的dtd,如果Doctype声明指定的是xhtml dtd,但文档包含的依旧是html标记就是不恰当的。类似的,如果文档包含的是xhtml 1.0 strict标记,但是Doctype声明指定是html dtd也是不恰当的。

      一、选择什么样的DOCTYPE?

      xhtml 1.0中有3种dtd声明可以选择,过渡性的(Transitional)、严格的(Strict)、框架的(Frameset)。下面我们来分别介绍:

      1、过渡的:一种要求不很严格的,允许在html中使用html 4.01的标识(符合xhtml语法标准),过渡的dtd写法如下:

    1. >  

      2、严格的:一种要求严格的dtd,不允许使用任何表现层的标识和属性,严格的dtd写法如下:


    1. >  

      3、框架的:一种专门针对框架页面所使用的dtd,当页面中含有框架元素时,就要采用这种dtd,写法如下:


    1. >  

      PS:使用严格的dtd来制作页面当然是最理想的方式,但是对于还没有深入了解web标准的网页设计者,比较适合用过渡的dtd,因为这种dtd还允许使用表现层的标识、元素和属性,比较适合大多数的网页制作人员(当然量力而为了!)

    二、什么是标准模式与混杂模式?

    不同文档模式主要影响CSS内容的呈现,尤其是浏览器对盒模型的解析,但在某些情况下也会影响到JavaScript的解释执行。
    1、文档模式目前有四种:

    混杂模式(quirks mode)
     //让IE的行为与(包含非标准特性的)IE5相同
    标准模式(standards mode)
    //让IE的行为更接近标准行为
    准标准模式(almost standards mode)
    //这种模式下的浏览器特性有很多都是符合标准的,不标准的地方主要体现在处理图片间隙的时候(在表格中使用图片时问题最明显)。
    超级标准模式:
    //IE8引入的一种新的文档模式,超级文档模式可以让IE以其所有版本中最符合标准的方式来解释网页内容。

    ps:
    总的来看,混杂模式让IE像IE5,标准模式使用IE7的呈现引擎,而超级标准模式则是IE8的默认文档模式。

    (另一篇关于混杂模式解释:

     什么是混杂模式呢?
      混杂模式是一种比较宽松的向后兼容的模式。混杂模式通常模拟老式浏览器的行为,以防止老站点无法工作

      为什么会有混杂模式呢?
      当年Netscape4(译注:网景公司早期的浏览器)和IE4(微软公司早期的浏览器)实现CSS机制时,并没有遵循W3C提出的标准。Netscape4 提供了糟糕的支持,而IE4 虽然接近标准,但依旧未能完全正确的支持标准。尽管IE 5 修复了IE4 许多的问题(bugs),但是依然延续CSS实现中的其它故障(主要是盒模型(box model)问题)。为了保障自己的网站在各个浏览器上显示正确,网页开发者们不得不依据各个浏览器自身的规范来使用css,因此大部分网站的css实现并不符合W3C规范的标准。然而随着标准一致性越来越重要,浏览器开发商不得不面临一个艰难的抉择:逐渐遵循W3C的标准是前进的方向。但是改变现有的 css,完全去遵循标准,会使许多旧网站或多或少受到破坏,如果浏览器突然以正确的方式解析现存的css,陈旧的网站的显示必然会受到影响。所以,所有的浏览器都需要提供两种模式:混杂模式服务与旧式规则,而严格模式服务于标准规则

    2、两种模式间的差异

    对于这两种模式之间的差异,最显著的一个例子与Windows上IE专有的盒模型有关。在IE 6出现时,在标准模式中使用的是正确的盒模型,在混杂模式中使用的则是老式的专有盒模型。为了维持对IE 5和更低版本的向后兼容性,Opera 7和更高版本也在混杂模式中使用有缺点的IE盒模型。

    呈现方面的其他差异比较小,而且是与特定浏览器相关的,包括对于十六进制颜色值不需要#号、假设CSS中没有指定单位的长度的单位是像素,以及在使用关键字时将字号增加一级。

区别:严格模式是浏览器根据规范去显示页面;混杂模式是以一种向后兼容的方式去显示
意义:决定浏览器如何渲染网站(浏览器使用那种规范去解析网页)
触发:浏览器根据doctype是否存在和使用的是那种dtd来决定。


  • 盒模型 —— 外边距、内边距和边框之间的关系,及IE8以下版本的浏览器中的盒模型
    一个元素盒模型的层次从内到外分别为:内边距、边框和外边距
    IE8以下浏览器的盒模型中定义的元素的宽高不包括内边距和边框


  • 块级元素与行内元素 —— 怎么用CSS控制它们、以及如何合理的使用它们
    行内元素,用CSS中的display:inline;属性则变为行内元素
    快级元素,用CSS中的display:block;属性则变为块级元素
    影响:周围元素显示在同一行或换行显示,根据具体情况调整样式


  • 浮动元素 —— 怎么使用它们、它们有什么问题以及怎么解决这些问题。
    需要浮动的元素可使用CSS中float属性来定义元素的浮动位置,left:往左浮动,right:往右浮动
    浮动元素引起的问题:
    (1)父元素的高度无法被撑开,影响与父元素同级的元素
    (2)与浮动元素同级的非浮动元素会跟随其后
    (3)若非第一个元素浮动,则该元素之前的元素也需要浮动,否则会影响页面显示的结构
    解决方法:
    使用CSS中的clear:both;属性来清除元素的浮动可解决2、3问题,对于问题1,添加如下样式,给父元素添加clearfix样式:
    .clearfix:after{content: ".";display: block;height: 0;clear: both;visibility: hidden;}
    .clearfix{display: inline-block;}  /* for IE/Mac */

  • HTML与XHTML —— 二者有什么区别,你觉得应该使用哪一个并说出理由。
    主要区别:
         XHTML 元素必须被正确地嵌套
         XHTML 元素必须被关闭,空标签也必须被关闭,如 
    必须写成
    XHTML 标签名必须用小写字母 XHTML 文档必须拥有根元素 XHTML 文档要求给所有属性赋一个值 XHTML 要求所有的属性必须用引号""括起来 XHTML 文档需要把所有 < 、>、& 等特殊符号用编码表示 XHTML 文档不要在注释内容中使“--” XHTML 图片必须有说明文字 XHTML 文档中用id属性代替name属性


  • JSON —— 作用、用途、设计结构。
    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。
    JSON建构于两种结构:
    “名称/值”对的集合(A collection of name/value 
    pairs)。不同的语言中,它被理解为对象(object),纪录(record),结构(struct),字典(dictionary),哈希表
    (hash table),有键列表(keyed list),或者关联数组 (associative array)。 
    值的有序列表(An ordered list of values)。在大部分语言中,它被理解为数组(array)。

  • Doctype作用?标准模式与兼容模式各有什么区别?

  (1)、声明位于位于HTML文档中的第一行,处于  标签之前。告知浏览器的解析器用什么文档标准解析这个文档。
   DOCTYPE不存在或格式不正确会导致文档以兼容模式呈现。

  (2)、标准模式的排版 和JS运作模式都是以该浏览器支持的最高标准运行。在兼容模式中,页面以宽松的向后兼容的方式显示,模拟
   老式浏览器的行为以防止站点无法工作。
  (3)、标准模式的宽度计算方式与兼容模式不同,给行内元素设置width和height无效,而兼容模式有效;标准模式当父元素没高度,
   子元素百分比无效,而兼容模式有效,使用margin:0 auto在标准模式下可以使元素水平居中,但在兼容模式下却会失效,解决办法,
   用text-align属性;兼容模式下设置图片padding失效,Table的字体属性不能继承上层设置,white-space:pre失效
  • HTML5 为什么只需要写

       HTML5 不基于 SGML,因此不需要对DTD(为了描述文档的结构,SGML定义了一个称为“文档类型定义(Document Type Definition,DTD)”
       的文件(file),它为组织文档的文档元素(例如章和章标题,节和主题等)提供了一个框架。此外,DTD还为文档元素之间的相互关系制定了
       规则。)进行引用,但是需要doctype来规范浏览器的行为(让浏览器按照它们应该的方式来运行);
    
       而HTML4.01基于SGML,所以需要对DTD进行引用,才能告知浏览器文档所使用的文档类型。
    
  • 行内元素有哪些?块级元素有哪些? 空(void)元素有那些?

      首先:CSS规范规定,每个元素都有display属性,确定该元素的类型,每个元素都有默认的display值,如div的display默认值为“block”,
      则为“块级”元素;span默认display属性值为“inline”,是“行内”元素。
    
      (1)行内元素有:a b span img input select strong(强调的语气)
      (2)块级元素有:div ul ol li dl dt dd h1 h2 h3 h4…p
    
      (3)常见的空元素(开始标签与结束标签之间没有内容的元素):
      	

    鲜为人知的是: * * 为页面上的所有链接规定默认地址或默认目标。 * 只有 Internet Explorer 9 (更早或更晚的版本都不支持)支持 标签。command 元素表示用户能够调用的命令。 * 标签定义嵌入的内容,比如插件。H5新增 * 标签规定用于表单的密钥对生成器字段。当提交表单时,私钥存储在本地,公钥发送到服务器。 *  此标签可为包含它的 或者 标签提供参数。 *  标签允许您规定可替换的视频/音频文件供浏览器根据它对媒体类型或者编解码器的支持进行选择。 * 标签为诸如 video 元素之类的媒介规定外部文本轨道。 *

    果想学习 AJAX HttpRequest 对象。

    规定在文本中的何处适合添加换行符。

    不同浏览器(版本)、HTML4(5)、CSS2等实际略有差异

    参考:

    • 页面导入样式时,使用link和@import有什么区别?

        (1)link属于XHTML标签,除了加载CSS外,还能用于定义RSS, 定义rel连接属性等作用;而@import是CSS提供的,
        只能用于加载CSS;
      
        (2)页面被加载的时,link会同时被加载,而@import引用的CSS会等到页面被加载完再加载;
      
        (3)import是CSS2.1 提出的,只在IE5以上才能被识别,而link是XHTML标签,无兼容问题;
      
         (4) @import会造成额外的请求(可自己写个例子在浏览器network查看)
      
    • 介绍一下你对浏览器内核的理解?

        主要分成两部分:渲染引擎(layout engineer或Rendering Engine)和JS引擎。
        渲染引擎:负责取得网页的内容(HTML、XML、图像等等)、整理讯息(例如加入CSS等),以及计算网页的显示方式,然
        后会输出至显示器或打印机。浏览器的内核的不同对于网页的语法解释会有不同,所以渲染的效果也不相同。所有网页浏
        览器、电子邮件客户端以及其它需要编辑、显示网络内容的应用程序都需要内核。
      
        JS引擎则:解析和执行javascript来实现网页的动态效果。
      
        最开始渲染引擎和JS引擎并没有区分的很明确,后来JS引擎越来越独立,内核就倾向于只指渲染引擎。
      
    • 常见的浏览器内核有哪些?

        Trident内核:IE,MaxThon,TT,The World,360,搜狗浏览器等。[又称MSHTML]
        Gecko内核:Netscape6及以上版本,FF,MozillaSuite/SeaMonkey等
        Presto内核:Opera7及以上。      [Opera内核原为:Presto,现为:Blink;]
        Webkit内核:Safari,Chrome等。   [ Chrome的:Blink(WebKit的分支)]
      

    浏览器内核的解析和对比

    • html5有哪些新特性、移除了那些元素?如何处理HTML5新标签的浏览器兼容问题?如何区分 HTML 和HTML5?

        * HTML5 现在已经不是 SGML 的子集,主要是关于图像,位置,存储,多任务等功能的增加。
        	  绘画 canvas;
        	  用于媒介回放的 video 和 audio 元素;
        	  本地离线存储 localStorage 长期存储数据,浏览器关闭后数据不丢失;
              sessionStorage 的数据在浏览器关闭后自动删除;
        	  语意化更好的内容元素,比如 article、footer、header、nav、section;
        	  表单控件,calendar、date、time、email、url、search;
        	  新的技术webworker, websocket, Geolocation;
      
          移除的元素:
        	  纯表现的元素:basefont,big,center,font, s,strike,tt,u;
        	  对可用性产生负面影响的元素:frame,frameset,noframes;
      
        * 支持HTML5新标签:
        	 IE8/IE7/IE6支持通过document.createElement方法产生的标签,
          	 可以利用这一特性让这些浏览器支持HTML5新标签,
          	 浏览器支持新标签后,还需要添加标签默认的样式。
      
             当然也可以直接使用成熟的框架、比如html5shim;
        	 
      
        * 如何区分HTML5: DOCTYPE声明\新增的结构元素\功能元素
      
    • 简述一下你对HTML语义化的理解?

        用正确的标签做正确的事情。
        html语义化让页面的内容结构化,结构更清晰,便于浏览器、搜索引擎的解析;
        即使在没有样式CSS情况下也以一种文档格式显示,并且是容易阅读的;
        搜索引擎的爬虫也依赖于HTML标记来确定上下文和各个关键字的权重,利于SEO;
        使阅读源代码的人对网站更容易将网站分块,便于阅读维护理解。
      
    • HTML5的离线储存怎么使用,工作原理能不能解释一下?

        在用户没有与因特网连接时,可以正常访问站点或应用,在用户与因特网连接时,更新用户机器上的缓存文件。
        原理:HTML5的离线存储是基于一个新建的.appcache文件的缓存机制(不是存储技术),通过这个文件上的解析清单
        离线存储资源,这些资源就会像cookie一样被存储了下来。之后当网络在处于离线状态下时,浏览器会通过被离线
        存储的数据进行页面展示。
      
      
        如何使用:
        1、页面头部像下面一样加入一个manifest的属性;
        2、在cache.manifest文件的编写离线存储的资源;
        	CACHE MANIFEST
        	#v0.11
        	CACHE:
        	js/app.js
        	css/style.css
        	NETWORK:
        	resourse/logo.png
        	FALLBACK:
        	/ /offline.html
        3、在离线状态时,操作window.applicationCache进行需求实现。
      

      详细的使用请参考:

      HTML5 离线缓存-manifest简介

      有趣的HTML5:离线存储

    • 浏览器是怎么对HTML5的离线储存资源进行管理和加载的呢?

        在线的情况下,浏览器发现html头部有manifest属性,它会请求manifest文件,如果是第一次访问app,
        那么浏览器就会根据manifest文件的内容下载相应的资源并且进行离线存储。如果已经访问过app并且资源已
        经离线存储了,那么浏览器就会使用离线的资源加载页面,然后浏览器会对比新的manifest文件与旧的manifest
        文件,如果文件没有发生改变,就不做任何操作,如果文件改变了,那么就会重新下载文件中的资源并进行离线存储。
        离线的情况下,浏览器就直接使用离线存储的资源。
      

      详细请参考:有趣的HTML5:离线存储

    • 请描述一下 cookies,sessionStorage 和 localStorage 的区别?

        cookie是网站为了标示用户身份而储存在用户本地终端(Client Side)上的数据(通常经过加密)。
        cookie数据始终在同源的http请求中携带(即使不需要),记会在浏览器和服务器间来回传递。
        sessionStorage和localStorage不会自动把数据发给服务器,仅在本地保存。
      
        存储大小:
        	cookie数据大小不能超过4k。
        	sessionStorage和localStorage 虽然也有存储大小的限制,但比cookie大得多,可以达到5M或更大。
      
        有期时间:
        	localStorage    存储持久数据,浏览器关闭后数据不丢失除非主动删除数据;
        	sessionStorage  数据在当前浏览器窗口关闭后自动删除。
        	cookie          设置的cookie过期时间之前一直有效,即使窗口或浏览器关闭
      
    • iframe有那些缺点?

        *iframe会阻塞主页面的Onload事件;
        *搜索引擎的检索程序无法解读这种页面,不利于SEO;
      
        *iframe和主页面共享连接池,而浏览器对相同域的连接有限制,所以会影响页面的并行加载。
      
        使用iframe之前需要考虑这两个缺点。如果需要使用iframe,最好是通过javascript
        动态给iframe添加src属性值,这样可以绕开以上两个问题。
      
    • Label的作用是什么?是怎么用的?

        label标签来定义表单控件间的关系,当用户选择该标签时,浏览器会自动将焦点转到和标签相关的表单控件上。
      
        
        
      
        
      
    • HTML5的form如何关闭自动完成功能?

        给不想要提示的 form 或某个 input 设置为 autocomplete=off。
      
    • 如何实现浏览器内多个标签页之间的通信? (阿里)

        WebSocket、SharedWorker;
        也可以调用localstorge、cookies等本地存储方式;
      
        localstorge另一个浏览上下文里被添加、修改或删除时,它都会触发一个事件,
        我们通过监听事件,控制它的值来进行页面信息通信;
        注意quirks:Safari 在无痕模式下设置localstorge值时会抛出 QuotaExceededError 的异常;
      
    • webSocket如何兼容低浏览器?(阿里)

        Adobe Flash Socket 、
        ActiveX HTMLFile (IE) 、
        基于 multipart 编码发送 XHR 、
        基于长轮询的 XHR
      
    • 页面可见性(Page Visibility API) 可以有哪些用途?

        通过 visibilityState 的值检测页面当前是否可见,以及打开网页的时间等;
        在页面被切换到其他后台进程的时候,自动暂停音乐或视频的播放;
      
    • 如何在页面上实现一个圆形的可点击区域?

        1、map+area或者svg
           通过usemap映射到的circle形。
        2、border-radius
        3、纯js实现 需要求一个点在不在圆上简单算法、获取鼠标坐标等等
            ```javascript
        		   document.onclick = function (e) {
        		    var x1 = 100,y1 = 100,x2 = e.clientX , y2 = clientY;
        		    var distance  = Math.abs(Math.sqrt(Math.pow(x2-x1,2) + Math.pow(y2-y1,2)));
        		    if (distance <= 50 ) {
        		   			console.log('in');
        		   	} else {
        		   		console.log("out");
        		   	}
        	    }   
        		```
      
    • 实现不使用 border 画出1px高的线,在不同浏览器的标准模式与怪异模式下都能保持一致的效果。

        
    • 网页验证码是干嘛的,是为了解决什么安全问题。

        区分用户是计算机还是人的公共全自动程序。可以防止恶意破解密码、刷票、论坛灌水;
        有效防止黑客对某一个特定注册用户用特定程序暴力破解方式进行不断的登陆尝试。
      
    • title与h1的区别、b与strong的区别、i与em的区别?

        title属性没有明确意义只表示是个标题,H1则表示层次明确的标题,对页面信息的抓取也有很大的影响;
      
        strong是标明重点内容,有语气加强的含义,使用阅读设备阅读网络时:会重读,而是展示强调内容。
      
        i内容展示为斜体,em表示强调的文本;
      
        Physical Style Elements -- 自然样式标签
        b, i, u, s, pre
        Semantic Style Elements -- 语义样式标签
        strong, em, ins, del, code
        应该准确使用语义样式标签, 但不能滥用, 如果不能确定时首选使用自然样式标签。
      

    CSS

    • 介绍一下标准的CSS的盒子模型?低版本IE的盒子模型有什么不同的?

        (1)有两种, IE 盒子模型、W3C 盒子模型;
        (2)盒模型: 内容(content)、填充(padding)、边界(margin)、 边框(border);
        (3)区  别: IE的content部分把 border 和 padding计算了进去;
      
    • CSS选择符有哪些?哪些属性可以继承?

        * 1.id选择器( # myid)
        	2.类选择器(.myclassname)
        	3.标签选择器(div, h1, p)
        	4.相邻选择器(h1 + p)
        	5.子选择器(ul > li)
        	6.后代选择器(li a)
        	7.通配符选择器( * )
        	8.属性选择器(a[rel = "external"])
        	9.伪类选择器(a:hover, li:nth-child)
      
        *   可继承的样式: font-size font-family color, UL LI DL DD DT;
      
        *   不可继承的样式:border padding margin width height ;
      
    • CSS优先级算法如何计算?

        *   优先级就近原则,同权重情况下样式定义最近者为准;
        *   载入样式以最后载入的定位为准;
      
        优先级为:
        	同权重: 内联样式表(标签内部)> 嵌入样式表(当前文件中)> 外部样式表(外部文件中)。
        	!important >  id > class > tag
        	important 比 内联优先级高
      
    • CSS3新增伪类有那些?

        	举例:
        	p:first-of-type	选择属于其父元素的首个 

      元素的每个

      元素。 p:last-of-type 选择属于其父元素的最后

      元素的每个

      元素。 p:only-of-type 选择属于其父元素唯一的

      元素的每个

      元素。 p:only-child 选择属于其父元素的唯一子元素的每个

      元素。 p:nth-child(2) 选择属于其父元素的第二个子元素的每个

      元素。 :after 在元素之前添加内容,也可以用来做清除浮动。 :before 在元素之后添加内容 :enabled :disabled 控制表单控件的禁用状态。 :checked 单选框或复选框被选中。

    • 如何居中div?

      • 水平居中:给div设置一个宽度,然后添加margin:0 auto属性

         div{
         	width:200px;
         	margin:0 auto;
          }
        
      • 让绝对定位的div居中

         div {
         	position: absolute;
         	width: 300px;
         	height: 300px;
         	margin: auto;
         	top: 0;
         	left: 0;
         	bottom: 0;
         	right: 0;
         	background-color: pink;	/* 方便看效果 */
         }
        
      • 水平垂直居中一

         确定容器的宽高 宽500 高 300 的层
         设置层的外边距
        
         div {
         	position: relative;		/* 相对定位或绝对定位均可 */
         	width:500px;
         	height:300px;
         	top: 50%;
         	left: 50%;
         	margin: -150px 0 0 -250px;     	/* 外边距为自身宽高的一半 */
         	background-color: pink;	 	/* 方便看效果 */
        
          }
        
      • 水平垂直居中二

         未知容器的宽高,利用 `transform` 属性
        
         div {
         	position: absolute;		/* 相对定位或绝对定位均可 */
         	width:500px;
         	height:300px;
         	top: 50%;
         	left: 50%;
         	transform: translate(-50%, -50%);
         	background-color: pink;	 	/* 方便看效果 */
        
         }
        
      • 水平垂直居中三

         利用 flex 布局
         实际使用时应考虑兼容性
        
         .container {
         	display: flex;
         	align-items: center; 		/* 垂直居中 */
         	justify-content: center;	/* 水平居中 */
        
         }
         .container div {
         	width: 100px;
         	height: 100px;
         	background-color: pink;		/* 方便看效果 */
         }  
        
    • display有哪些值?说明他们的作用。

          block       	块类型。默认宽度为父元素宽度,可设置宽高,换行显示。
          none        	缺省值。象行内元素类型一样显示。
          inline      	行内元素类型。默认宽度为内容宽度,不可设置宽高,同行显示。
          inline-block  默认宽度为内容宽度,可以设置宽高,同行显示。
          list-item   	象块类型元素一样显示,并添加样式列表标记。
          table       	此元素会作为块级表格来显示。
          inherit     	规定应该从父元素继承 display 属性的值。
      
    • position的值relative和absolute定位原点是?

          absolute
        	生成绝对定位的元素,相对于值不为 static的第一个父元素进行定位。
          fixed (老IE不支持)
        	生成绝对定位的元素,相对于浏览器窗口进行定位。
          relative
        	生成相对定位的元素,相对于其正常位置进行定位。
          static
        	默认值。没有定位,元素出现在正常的流中(忽略 top, bottom, left, right z-index 声明)。
          inherit
        	规定从父元素继承 position 属性的值。
      
    • CSS3有哪些新特性?

          新增各种CSS选择器	(: not(.input):所有 class 不是“input”的节点)
          圆角		    (border-radius:8px)
          多列布局	    (multi-column layout)
          阴影和反射	(Shadow\Reflect)
          文字特效		(text-shadow、)
          文字渲染		(Text-decoration)
          线性渐变		(gradient)
          旋转		 	(transform)
          缩放,定位,倾斜,动画,多背景
          例如:transform:\scale(0.85,0.90)\ translate(0px,-30px)\ skew(-9deg,0deg)\Animation:
      
    • 请解释一下CSS3的Flexbox(弹性盒布局模型),以及适用场景?

         一个用于页面布局的全新CSS3功能,Flexbox可以把列表放在同一个方向(从上到下排列,从左到右),并让列表能延伸到占用可用的空间。
         较为复杂的布局还可以通过嵌套一个伸缩容器(flex container)来实现。
         采用Flex布局的元素,称为Flex容器(flex container),简称"容器"。
         它的所有子元素自动成为容器成员,称为Flex项目(flex item),简称"项目"。
         常规布局是基于块和内联流方向,而Flex布局是基于flex-flow流可以很方便的用来做局中,能对不同屏幕大小自适应。
         在布局上有了比以前更加灵活的空间。
      


    • 用纯CSS创建一个三角形的原理是什么?

        把上、左、右三条边隐藏掉(颜色设为 transparent)
        #demo {
          width: 0;
          height: 0;
          border-width: 20px;
          border-style: solid;
          border-color: transparent transparent red transparent;
        }
      
    • 一个满屏 品 字布局 如何设计?

        简单的方式:
        	上面的div宽100%,
        	下面的两个div分别宽50%,
        	然后用float或者inline使其不换行即可
      
    • css多列等高如何实现?

        利用padding-bottom|margin-bottom正负值相抵;
        设置父容器设置超出隐藏(overflow:hidden),这样子父容器的高度就还是它里面的列没有设定padding-bottom时的高度,
        当它里面的任 一列高度增加了,则父容器的高度被撑到里面最高那列的高度,
        其他比这列矮的列会用它们的padding-bottom补偿这部分高度差。
      
    • 经常遇到的浏览器的兼容性有哪些?原因,解决方法是什么,常用hack的技巧 ?

        * png24位的图片在iE6浏览器上出现背景,解决方案是做成PNG8.
      
        * 浏览器默认的margin和padding不同。解决方案是加一个全局的*{margin:0;padding:0;}来统一。
      
        * IE6双边距bug:块属性标签float后,又有横行的margin情况下,在ie6显示margin比设置的大。
      
          浮动ie产生的双倍距离 #box{ float:left; width:10px; margin:0 0 0 10px;}
      
          这种情况之下IE会产生20px的距离,解决方案是在float的标签样式控制中加入 ——_display:inline;将其转化为行内属性。
        		(_这个符号只有ie6会识别)
      
          渐进识别的方式,从总体中逐渐排除局部。
      
          首先,巧妙的使用“\9”这一标记,将IE游览器从所有情况中分离出来。
          接着,再次使用“+”将IE8和IE7、IE6分离开来,这样IE8已经独立识别。
      
          css
              .bb{
                  background-color:red;/*所有识别*/
        	      background-color:#00deff\9; /*IE6、7、8识别*/
        	      +background-color:#a200ff;/*IE6、7识别*/
        	      _background-color:#1e0bd1;/*IE6识别*/
              }
      
      
        *  IE下,可以使用获取常规属性的方法来获取自定义属性,
           也可以使用getAttribute()获取自定义属性;
           Firefox下,只能使用getAttribute()获取自定义属性。
           解决方法:统一通过getAttribute()获取自定义属性。
      
        *  IE下,even对象有x,y属性,但是没有pageX,pageY属性;
           Firefox下,event对象有pageX,pageY属性,但是没有x,y属性。
      
        *  解决方法:(条件注释)缺点是在IE浏览器下可能会增加额外的HTTP请求数。
      
        *  Chrome 中文界面下默认会将小于 12px 的文本强制按照 12px 显示,
           可通过加入 CSS 属性 -webkit-text-size-adjust: none; 解决。
      
        超链接访问过后hover样式就不出现了 被点击访问过的超链接样式不在具有hover和active了解决方法是改变CSS属性的排列顺序:
        L-V-H-A :  a:link {} a:visited {} a:hover {} a:active {}
      
    • li与li之间有看不见的空白间隔是什么原因引起的?有什么解决办法?

        行框的排列会受到中间空白(回车\空格)等的影响,因为空格也属于字符,这些空白也会被应用样式,占据空间,
        所以会有间隔,把字符大小设为0,就没有空格了。
      
    • 为什么要初始化CSS样式。

        - 因为浏览器的兼容问题,不同浏览器对有些标签的默认值是不同的,如果没对CSS初始化往往会出现浏览器之间的页面显示差异。
      
        - 当然,初始化样式会对SEO有一定的影响,但鱼和熊掌不可兼得,但力求影响最小的情况下初始化。
      
        最简单的初始化方法: * {padding: 0; margin: 0;} (强烈不建议)
      
        淘宝的样式初始化代码:
        body, h1, h2, h3, h4, h5, h6, hr, p, blockquote, dl, dt, dd, ul, ol, li, pre, form, fieldset, legend, button,
        input, textarea, th, td { margin:0; padding:0; }
        body, button, input, select, textarea { font:12px/1.5tahoma, arial, \5b8b\4f53; }
        h1, h2, h3, h4, h5, h6{ font-size:100%; }
        address, cite, dfn, em, var { font-style:normal; }
        code, kbd, pre, samp { font-family:couriernew, courier, monospace; }
        small{ font-size:12px; }
        ul, ol { list-style:none; }
        a { text-decoration:none; }
        a:hover { text-decoration:underline; }
        sup { vertical-align:text-top; }
        sub{ vertical-align:text-bottom; }
        legend { color:#000; }
        fieldset, img { border:0; }
        button, input, select, textarea { font-size:100%; }
        table { border-collapse:collapse; border-spacing:0; }
      
    • absolute的containing block(容器块)计算方式跟正常流有什么不同?

          无论属于哪种,都要先找到其祖先元素中最近的 position 值不为 static 的元素,然后再判断:
        1、若此元素为 inline 元素,则 containing block 为能够包含这个元素生成的第一个和最后一个 inline box 的
        padding box (除 margin, border 外的区域) 的最小矩形;
        2、否则,则由这个祖先元素的 padding box 构成。
        如果都找不到,则为 initial containing block。
      
        补充:
        1. static(默认的)/relative:简单说就是它的父元素的内容框(即去掉padding的部分)
        2. absolute: 向上找最近的定位为absolute/relative的元素
        3. fixed: 它的containing block一律为根元素(html/body),根元素也是initial containing block
      
    • CSS里的visibility属性有个collapse属性值是干嘛用的?在不同浏览器下以后什么区别?

      对于普通元素visibility:collapse;会将元素完全隐藏,不占据页面布局空间,与display:none;表现相同.如果目标元素为table,visibility:collapse;将table隐藏,但是会占据页面布局空间.仅在Firefox下起作用,IE7及以下会显示元素,Chrome会将元素隐藏,但是占据空间.

    • position跟display、margin collapse、overflow、float这些特性相互叠加后会怎么样?

      如果元素的display为none,那么元素不被渲染,position,float不起作用,如果元素拥有position:absolute;或者position:fixed;属性那么元素将为绝对定位,float不起作用.如果元素float属性不是none,元素会脱离文档流,根据float属性值来显示.有浮动,绝对定位,inline-block属性的元素,margin不会和垂直方向上的其他元素margin折叠.

    • 对BFC规范(块级格式化上下文:block formatting context)的理解?

        (W3C CSS 2.1 规范中的一个概念,它是一个独立容器,决定了元素如何对其内容进行定位,以及与其他元素的关系和相互作用。)
         一个页面是由很多个 Box 组成的,元素的类型和 display 属性,决定了这个 Box 的类型。
         不同类型的 Box,会参与不同的 Formatting Context(决定如何渲染文档的容器),因此Box内的元素会以不同的方式渲染,
         也就是说BFC内部的元素和外部的元素不会互相影响。
      
    • css定义的权重

        以下是权重的规则:标签的权重为1,class的权重为10,id的权重为100,以下例子是演示各种定义的权重值:
      
        /*权重为1*/
        div{
        }
        /*权重为10*/
        .class1{
        }
        /*权重为100*/
        #id1{
        }
        /*权重为100+1=101*/
        #id1 div{
        }
        /*权重为10+1=11*/
        .class1 div{
        }
        /*权重为10+10+1=21*/
        .class1 .class2 div{
        }
      
        如果权重相同,则最后定义的样式会起作用,但是应该避免这种情况出现
      
    • 请解释一下为什么需要清除浮动?清除浮动的方式

      清除浮动是为了清除使用浮动元素产生的影响。浮动的元素,高度会塌陷,而高度的塌陷使我们页面后面的布局不能正常显示。

        1、父级div定义height;
        2、父级div 也一起浮动;
        3、常规的使用一个class;
        	.clearfix:before, .clearfix:after {
        	    content: " ";
        	    display: table;
        	}
        	.clearfix:after {
        	    clear: both;
        	}
        	.clearfix {
        	    *zoom: 1;
        	}
      
        4、SASS编译的时候,浮动元素的父级div定义伪类:after
        	&:after,&:before{
        	    content: " ";
                visibility: hidden;
                display: block;
                height: 0;
                clear: both;
        	}
      
        解析原理:
        1) display:block 使生成的元素以块级元素显示,占满剩余空间;
        2) height:0 避免生成内容破坏原有布局的高度。
        3) visibility:hidden 使生成的内容不可见,并允许可能被生成内容盖住的内容可以进行点击和交互;
        4)通过 content:"."生成内容作为最后一个元素,至于content里面是点还是其他都是可以的,
        例如oocss里面就有经典的 content:".",有些版本可能content 里面内容为空,一丝冰凉是
        不推荐这样做的,firefox直到7.0 content:”" 仍然会产生额外的空隙;
        5)zoom:1 触发IE hasLayout。
      
        通过分析发现,除了clear:both用来闭合浮动的,其他代码无非都是为了隐藏掉content生成的内容,
        这也就是其他版本的闭合浮动为什么会有font-size:0,line-height:0。
      
    • 什么是外边距合并?

        外边距合并指的是,当两个垂直外边距相遇时,它们将形成一个外边距。
        合并后的外边距的高度等于两个发生合并的外边距的高度中的较大者。
        [w3school介绍网址:](http://www.w3school.com.cn/css/css_margin_collapsing.asp)
      
    • zoom:1的清除浮动原理?

        清除浮动,触发hasLayout;
        Zoom属性是IE浏览器的专有属性,它可以设置或检索对象的缩放比例。解决ie下比较奇葩的bug。
        譬如外边距(margin)的重叠,浮动清除,触发ie的haslayout属性等。
      
        来龙去脉大概如下:
        当设置了zoom的值之后,所设置的元素就会就会扩大或者缩小,高度宽度就会重新计算了,这里
        一旦改变zoom值时其实也会发生重新渲染,运用这个原理,也就解决了ie下子元素浮动时候父元素不随着自动扩大的问题。
      
        Zoom属是IE浏览器的专有属性,火狐和老版本的webkit核心的浏览器都不支持这个属性。然而,
        zoom现在已经被逐步标准化,出现在 CSS 3.0 规范草案中。
      
        目前非ie由于不支持这个属性,它们又是通过什么属性来实现元素的缩放呢?
        可以通过css3里面的动画属性scale进行缩放。
      
    • 移动端的布局用过媒体查询吗?

      假设你现在正用一台显示设备来阅读这篇文章,同时你也想把它投影到屏幕上,或者打印出来,而显示设备、屏幕投影和打印等这些媒介都有自己的特点,CSS就是为文档提供在不同媒介上展示的适配方法

      当媒体查询为真时,相关的样式表或样式规则会按照正常的级联规被应用。当媒体查询返回假, 标签上带有媒体查询的样式表 仍将被下载 (只不过不会被应用)。

      包含了一个媒体类型和至少一个使用 宽度、高度和颜色等媒体属性来限制样式表范围的表达式。CSS3加入的媒体查询使得无需修改内容便可以使样式应用于某些特定的设备范围。

    • 使用 CSS 预处理器吗?喜欢那个?

        SASS (SASS、LESS没有本质区别,只因为团队前端都是用的SASS)
      
    • CSS优化、提高性能的方法有哪些?

        关键选择器(key selector)。选择器的最后面的部分为关键选择器(即用来匹配目标元素的部分);
        如果规则拥有 ID 选择器作为其关键选择器,则不要为规则增加标签。过滤掉无关的规则(这样样式系统就不会浪费时间去匹配它们了);
        提取项目的通用公有样式,增强可复用性,按模块编写组件;增强项目的协同开发性、可维护性和可扩展性;
        使用预处理工具或构建工具(gulp对css进行语法检查、自动补前缀、打包压缩、自动优雅降级);
      
    • 浏览器是怎样解析CSS选择器的?

        样式系统从关键选择器开始匹配,然后左移查找规则选择器的祖先元素。
        只要选择器的子树一直在工作,样式系统就会持续左移,直到和规则匹配,或者是因为不匹配而放弃该规则。(从右往左匹配全部选择器)
      
    • 在网页中的应该使用奇数还是偶数的字体?为什么呢?

      • 偶数字号相对更容易和 web 设计的其他部分构成比例关系。
      • Windows 自带的点阵宋体(中易宋体)从 Vista 开始只提供 12、14、16 px 这三个大小的点阵,而 13、15、17 px 时用的是小一号的点阵(即每个字占的空间大了 1 px,但点阵没变),于是略显稀疏。
      • 使用偶数是一种习惯的延续,并且12px和14px字体能形成更好的层次与对比。使用奇数号字体不好的地方是,文本段落无法对齐。
    • margin和padding分别适合什么场景使用?

        margin是用来隔开元素与元素的间距;padding是用来隔开元素与内容的间隔。
        margin用于布局分开元素使元素与元素互不相干;
        padding用于元素与内容之间的间隔,让内容(文字)与(包裹)元素之间有一段
      
    • 抽离样式模块怎么写,说出思路,有无实践经验?[阿里航旅的面试题]

      先通读视觉稿,把所有类似的、可复用的部分划分出来,抽出结构和样式做成模块。达到一段 HTML 代码、一段 CSS 样式,粘贴到任意位置都正常。

    • 元素竖向的百分比设定是相对于容器的高度吗?

      对于一些表示竖向距离的属性,例如padding-top,padding-bottom,margin-top,margin-bottom等,当按百分比设定它们时,依据的是父容器的宽度,而不是高度。

    • 全屏滚动的原理是什么?用到了CSS的那些属性?

      主要呈现方式有两种,一种是整体的元素一直排列下去,假设有五个需要展示的全屏页面,那么高度是500%,只是展示100%,剩下的可以通过tranform进行Y轴定位,也可以通过margin-top实现,第二种就是所有的子元素和页面一样,都显示在当前页面。

    • 什么是响应式设计?响应式设计的基本原理是什么?如何兼容低版本的IE?

      • 面的设计和开发应当根据用户行为以及设备环境(系统平台、屏幕尺寸、屏幕定向等)进行相应的响应和调整.
      • 响应式设计的基本原理是通过媒体查询检测不同的设备屏幕尺寸做处理。页面头部必须有meta声明viewport:
           <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no”>
      • 兼容方案
        •  通过resize方法来实现PC端响应式
             $(window).resize(function () {
                screenRespond();
             });
    • 视差滚动效果,如何给每页做不同的动画?(回到顶部,向下滑动要再次出现,和只出现一次分别怎么做?)

      在web设计中,通过运用多层背景在以不同速度运动的情况下,形成的一种立体的运动效果,这种视觉体验,我们称之为视差效果。

      * 1, 实现方式 css background-attachment: fixed;
      * 2, 插件
      * 3, [链接](http://www.alloyteam.com/2014/02/optimized-articles-of-parallax-scrolling-love-story/)
      
    • ::before 和 :after中双冒号和单冒号 有什么区别?解释一下这2个伪元素的作用。

        单冒号(:)用于CSS3伪类,双冒号(::)用于CSS3伪元素。(伪元素由双冒号和伪元素名称组成)
        双冒号是在当前规范中引入的,用于区分伪类和伪元素。不过浏览器需要同时支持旧的已经存在的伪元素写法,
        比如:first-line、:first-letter、:before、:after等,
        而新的在CSS3中引入的伪元素则不允许再支持旧的单冒号的写法。
      
        想让插入的内容出现在其它内容前,使用::before,否者,使用::after;
        在代码顺序上,::after生成的内容也比::before生成的内容靠后。
        如果按堆栈视角,::after生成的内容会在::before生成的内容之上
      
    • 如何修改chrome记住密码后自动填充表单的黄色背景 ?

        input:-webkit-autofill, textarea:-webkit-autofill, select:-webkit-autofill {
          background-color: rgb(250, 255, 189); /* #FAFFBD; */
          background-image: none;
          color: rgb(0, 0, 0);
        }
      
    • 你对line-height是如何理解的?

      line-height定义行高,设置行间的距离。应用方式是:用line-height减去font-size,得到的差(称为行间距)除2,分别添加到文本的顶部和底部。可以包含这些内容的最小框就是行框。

    • 设置元素浮动后,该元素的display值是多少?

      自动变成了 display:block解决bug:(1)给浮动元素添加一个display:inline (2)给IE6写一个hack,其值为正常值的一半。

    • 怎么让Chrome支持小于12px 的文字?

        1、用图片:如果是内容固定不变情况下,使用将小于12px文字内容切出做图片,这样不影响兼容也不影响美观。
        2、使用12px及12px以上字体大小:为了兼容各大主流浏览器,建议设计美工图时候设置大于或等于12px的字体大小,
        如果是接单的这个时候就需要给客户讲解小于12px浏览器不兼容等事宜。
        3、继续使用小于12px字体大小样式设置:如果不考虑chrome可以不用考虑兼容,同时在设置小于12px对象设置
        -webkit-text-size-adjust:none(PC上已失效),做到最大兼容考虑。改为 transform:scale(0.875);
        [实现](https://www.zhihu.com/question/21093147?rf=21339583)
        4、使用12px以上字体:为了兼容、为了代码更简单 从新考虑权重下兼容性。
      
    • 让页面里的字体变清晰,变细用CSS怎么做?

        -webkit-font-smoothing: antialiased;
      
    • font-style属性可以让它赋值为“oblique” oblique是什么意思?

        倾斜的字体样式(在css规范中这么描述的,让一种字体表示为斜体(oblique),如果没有这样样式,
        就可以使用 italic。oblique是一种倾斜的文字,不是斜体。)
      
    • position:fixed;在android下无效怎么处理?

        fixed的元素是相对整个页面固定位置的,你在屏幕上滑动只是在移动这个所谓的viewport,
        原来的网页还好好的在那,fixed的内容也没有变过位置,
        所以说并不是iOS不支持fixed,只是fixed的元素不是相对手机屏幕固定的。
        
      
    • 如果需要手动写动画,你认为最小时间间隔是多久,为什么?(阿里)

        多数显示器默认频率是60Hz,即1秒刷新60次,所以理论上最小间隔为1/60*1000ms = 16.7ms
      
    • display:inline-block 什么时候会显示间隙?(携程)

        有空格的时候会有间隙(两个display:inline-block的默认的空格或者换行符),解决方法 移除空格、
        使用margin负值、使用font-size:0、letter-spacing、word-spacing
      
    • overflow: scroll时不能平滑滚动的问题怎么处理?

      (1)-webkit-overflow-scrolling: touch;,是因为这行代码启用了硬件加速特性,所以滑动很流畅。

    • (2) isroll 方案

    •   overflow: auto 当页面出现滚动条时,会造成
        [跳动问题](http://www.zhangxinxu.com/wordpress/2015/01/css-page-scrollbar-toggle-center-no-jumping/)
      
      • (1)高度尺寸不确定的时候,使用:overflow-y:scroll;
      • (2)高度尺寸确定的,要么没有滚动条,要么直接出现,不会出现跳动。
      • (3)```javascript.wrap-outer {margin-left: calc(100vw - 100%);}或.wrap-outer {padding-left: calc(100vw - 100%);}
        
        

      首先,.wrap-outer指的是居中定宽主体的父级,如果没有,创建一个(使用主体也是可以实现类似效果,不过本着宽度分离原则,不推荐);然后,calc是CSS3中的计算,IE10+浏览器支持,IE9浏览器基本支持(不能用在background-position上);最后,100vw相对于浏览器的window.innerWidth,是浏览器的内部宽度,注意,滚动条宽度也计算在内!而100%是可用宽度,是不含滚动条的宽度。于是,calc(100vw - 100%)就是浏览器滚动条的宽度大小(如果有,如果没有滚动条则是0)!左右都有一个滚动条宽度(或都是0)被占用,主体内容就可以永远居中浏览器啦,从而没有任何跳动!

    • 有一个高度自适应的div,里面有两个div,一个高度100px,希望另一个填满剩下的高度。

      *(1)height:calc(100%-100px)*(2)absolute positioning:外层position:relative;百分百自适应元素position: absolute; top: 100px; bottom: 0; left: 0

      • flex 父元素display:flex; flex-direction: column; 下面的子元素的设置flex: 1;
    • png、jpg、gif 这些图片格式解释一下,分别什么时候用。有没有了解过webp?

      • 1, png是便携式网络图片(Portable Network Graphics)是一种无损数据压缩位图文件格式,优点是:压缩比高,色彩好。 大多数地方都可以用。
      • 2, jpg是一种针对相片使用的一种失真压缩方法,是一种破坏性的压缩,在色调及颜色平滑变化做的 不错。在www上,被用来储存和传输照片的格式。
      • 3, gif是一种位图文件格式,以8位色重现真色彩的图像。可以实现动画效果时候

      webp格式是谷歌在2010年推出的图片格式,压缩率只有jpg的2/3,大小比png小了45%,缺点是压缩的时间更久了。兼容性不好,目前谷歌和opera支持。

    • 什么是Cookie 隔离?(或者说:请求资源的时候不要让它带cookie怎么做)

        如果静态文件都放在主域名下,那静态文件请求的时候都带有的cookie的数据提交给server的,非常浪费流量,
        所以不如隔离开。
      

      静态资源放 CDN ,用 cookie free domain因为cookie有域的限制,因此不能跨域提交请求,故使用非主要域名的时候,请求头中就不会带有cookie数据,这样可以降低请求头的大小,降低请求时间,从而达到降低整体请求延时的目的。

        同时这种方式不会将cookie传入Web Server,也减少了Web Server对cookie的处理分析环节,
        提高了webserver的http请求的解析速度。
      
    • style标签写在body后与body前有什么区别?

      * 1, 写在head标签中利于浏览器逐步渲染(resources downloading->CSSOM+DOM->RenderTree(composite)->Layout->paint)。   CSS,解析CSS会产生CSS规则树。Javascript,脚本,主要是通过DOM API和CSSOM API来操作DOM Tree和CSS Rule Tree.

      * 2, 写在body标签后由于浏览器以逐行方式对html文档进行解析,当解析到写在尾部的样式表(外联或写在style标签)会导致浏览器停止之前的渲染,等待加载且解析样式表完成之后重新渲染,在windows的IE下可能会出现FOUC现象(即样式失效导致的页面闪烁问题)

    • 基础知识——浏览器的渲染过程:(CSSOM视图模块(CSS Object Model View)

      • 1, Create/Update DOM And request css/image/js:浏览器请求到HTML代码后,在生成DOM的最开始阶段(应该是 Bytes → characters 后),并行发起css、图片、js的请求,无论他们是否在HEAD里。注意:发起 js 文件的下载 request 并不需要 DOM 处理到那个 script 节点,比如:简单的正则匹配就能做到这一点,虽然实际上并不一定是通过正则:)。这是很多人在理解渲染机制的时候存在的误区。
      • 2, Create/Update Render CSSOM:CSS文件下载完成,开始构建CSSOM
      • 3, Create/Update Render Tree:所有CSS文件下载完成,CSSOM构建结束后,和 DOM 一起生成 Render Tree。
      • 4, Layout:有了Render Tree,浏览器已经能知道网页中有哪些节点、各个节点的CSS定义以及他们的从属关系。下一步操作称之为Layout,顾名思义就是计算出每个节点在屏幕中的位置。
      • 5, Painting:Layout后,浏览器已经知道了哪些节点要显示(which nodes are visible)、每个节点的CSS属性是什么(their computed styles)、每个节点在屏幕中的位置是哪里(geometry)。就进入了最后一步:Painting,按照算出来的规则,通过显卡,把内容画到屏幕上。

      补充:

      • 1, Repaint(重绘):屏幕的一部分要重画。
      • 2, Reflow(回流):元件的几何尺寸变化了。要重新验证并计算Render Tree
      • 3, 联想——有 async,加载和渲染后续文档元素的过程将和 script.js 的加载并行进行(异步)。加载完成立即执行,并阻止页面解析html,并且不能保证按顺序执行。
      • 有 defer,加载后续文档元素的过程将和 script.js 的加载并行进行(异步),但是 script.js的执行要在所有元素解析完成之后,DOMContentLoaded 事件触发之前完成。按照加载顺序执行脚本的

      注意:DOM树构建完成。//DOMContentLoaded ,页面加载完毕。//load

    • Ajax 是什么? 如何创建一个Ajax?

       ajax的全称:Asynchronous Javascript And XML。
       异步传输+js+xml。
       所谓异步,在这里简单地解释就是:向服务器发送请求的时候,我们不必等待结果,而是可以同时做其他的事情,
       等到有了结果它自己会根据设定进行后续操作,与此同时,页面是不会发生整页刷新的,提高了用户体验。
      
       (1)创建XMLHttpRequest对象,也就是创建一个异步调用对象
       (2)创建一个新的HTTP请求,并指定该HTTP请求的方法、URL及验证信息
       (3)设置响应HTTP请求状态变化的函数
       (4)发送HTTP请求
       (5)获取异步调用返回的数据
       (6)使用JavaScript和DOM实现局部刷新
      
    • Ajax 解决浏览器缓存问题?

        1、在ajax发送请求前加上 xhr.setRequestHeader("If-Modified-Since","0")。
      
        2、在ajax发送请求前加上 xhr.setRequestHeader("Cache-Control","no-cache")。
      
        3、在URL后面加上一个随机数: "fresh=" + Math.random();。
      
        4、在URL后面加上时间搓:"nowtime=" + new Date().getTime();。
      
        5、如果是使用jQuery,直接这样就可以了 $.ajaxSetup({cache:false})。这样页面的所有ajax
        		都会执行这条语句就是不需要保存缓存记录。
      
    • 同步和异步的区别?

      同步的概念应该是来自于OS中关于同步的概念:不同进程为协同完成某项工作而在先后次序上调整(通过阻塞,唤醒等方式).同步强调的是顺序性.谁先谁后.异步则不存在这种顺序性.

      同步:浏览器访问服务器请求,用户看得到页面刷新,重新发请求,等请求完,页面刷新,新内容出现,用户看到新内容,进行下一步操作。

      异步:浏览器访问服务器请求,用户正常操作,浏览器后端进行请求。等请求完,页面不刷新,新内容也会出现,用户看到新内容。

      来源网络:

      • 1, 老张把水壶放到火上,立等水开。(同步阻塞)老张觉得自己有点傻
      • 2, 老张把水壶放到火上,去客厅看电视,时不时去厨房看看水开没有。(同步非阻塞)老张还是觉得自己有点傻,于是变高端了,买了把会响笛的那种水壶。水开之后,能大声发出嘀~~~~的噪音。
      • 3, 老张把响水壶放到火上,立等水开。(异步阻塞)老张觉得这样傻等意义不大
      • 4, 老张把响水壶放到火上,去客厅看电视,水壶响之前不再去看它了,响了再去拿壶。(异步非阻塞)
    • 如何解决跨域问题?

      需要html5支持

      • 1, window.postMessage('数据',域名); 子域监听Message方法
      • 2, 利用 cors 通过设置请求头或者在服务器设置 来解决跨域

      其他

      • 3, 利用window.name 跨域
      • 4, jsonp
      • 6, document.domain 只要把子页面的document.domain都指向主域就可以了,比如document.domain='foo.com';
        //设置好后父页面和子页面就可以像同一个域下两个页面之间访问了。父页面通过ifr.contentWindow就可以访问子页面的window,子页面通过parent.window或parent访问父页面的window,接下来可以进一步获取dom和js 。
      • 7, ie6/7 window.navigator 子域和父域共享同一个对象,通过增加对象属性或方法进行调用
        • 8, 服务器代理
    • 页面编码和被请求的资源编码如果不一致如何处理?

      web编码总结

      • 指定编码方式
      • h5废弃了charset这个属性, 改为在文件内部写@charset utf-8
    • 模块化开发怎么做?

      立即执行函数,不暴露私有成员

          var module1 = (function(){
           var _count = 0;
           var m1 = function(){
             //...
           };
           var m2 = function(){
             //...
           };
           return {
             m1 : m1,
             m2 : m2
           };
         })();

      (待完善)无模块时代问题* 1,全局变量灾难* 2,函数命名冲突* 3,依赖关系不好处理

      解决方案

      * 1,用自执行函数
      * 2,类似java命名空间方式进行管理
      * 3,jquery风格匿名自执行函数
      

      模块化面临问题

        1. 如何安全的包装一个模块的代码?(不污染模块外的任何代码)
        1. 如何唯一标识一个模块?
        1. 如何优雅的把模块的API暴漏出去?(不能增加全局变量)
        1. 如何方便的使用所依赖的模块?

      Modules/1.x规范 (Commonjs)

        1. 模块的标识应遵循的规则(书写规范)
        1. 定义全局函数require,通过传入模块标识来引入其他模块,执行的结果即为别的模块暴漏出来的API
        1. 如果被require函数引入的模块中也包含依赖,那么依次加载这些依赖
        1. 如果引入模块失败,那么require函数应该报一个异常
        1. 模块通过变量exports来向往暴漏API,exports只能是一个对象,暴漏的API须作为此对象的属性。

      前端问题

      • 1, 变量暴露在全局
      • 2, 资源加载方式不同,浏览器需http请求获得,服务端直接从内存读取

      解决方法

      • 1, 升级Modules/1.0规范
      • 2,重新制定浏览器端规范AMD(Asynchronous Module Definition)(requireJS)
      • 3, 中间派 Modules/Wrappings规范 (seajs)
    • AMD(Modules/Asynchronous-Definition)、CMD(Common Module Definition)规范区别?

      AMD 规范在这里:https://github.com/amdjs/amdjs-api/wiki/AMD

      CMD 规范在这里:https://github.com/seajs/seajs/issues/242

       Asynchronous Module Definition,异步模块定义,所有的模块将被异步加载,模块加载不影响后面语句运行。所有依赖某些模块的语句均
       放置在回调函数中。factory 的参数差异,直接导致 AMD 中的模块是立刻执行的,而 Wrappings 中的模块可以等到第一次 require 时才执行。
       
       区别:
      
           * 1. 对于依赖的模块,AMD 是提前执行,CMD 是延迟执行。不过 RequireJS 从 2.0 开始,也改成可以延迟执行(根据写法不同,处理方式不同)。CMD 推崇 as lazy as possible.
           * 2. CMD 推崇依赖就近,AMD 推崇依赖前置。看代码:
      
             // CMD
               define(function(require, exports, module) {
              		 var a = require('./a')
              		 a.doSomething()
              		 // 此处略去 100 行
              		 var b = require('./b') // 依赖可以就近书写
              		 b.doSomething()
              		 // ...
               })
      
               // AMD 默认推荐
               define(['./a', './b'], function(a, b) { // 依赖必须一开始就写好
              		 a.doSomething()
              		 // 此处略去 100 行
              		 b.doSomething()
              		 // ...
               })
          ```
      

    SeaJS 和 RequireJS 的异同

    • requireJS的核心原理是什么?(如何动态加载的?如何避免多次加载的?如何缓存的?)

      参考:

    • JS模块加载器的轮子怎么造,也就是如何实现一个模块加载器?

      如何实现一个 CMD 模块加载器

    • 谈一谈你对ECMAScript6的了解?

    • ECMAScript6 怎么写class么,为什么会出现class这种东西?

            class Ponit{
           	constructor(x, y){
           		this.x = x;
           		this.y = y;
           	}
      
           	toString(){
           		return '(' + this.x +','+ this.y + ')';
           	}
           }

    JS原型继承方法写法跟传统的面向对象语言(比如 C++ 和 Java)差异很大,很容易让新学习这门语言的程序员感到困惑。ES6提供了更接近传统语言的写法,引入了Class(类);作为对象的模板。通过class关键字,可以定义类。class其实只是一个语法糖,它的绝大部分功能ES5 都可以做到,新的class写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。

    • 异步加载JS的方式有哪些?

         (1) defer,只支持IE
      
         (2) async:
      
         (3) 创建script,插入到DOM中,加载完毕后callBack
      
    • documen.write和 innerHTML的区别

        document.write只能重绘整个页面
      
        innerHTML可以重绘页面的一部分
      
    • DOM操作——怎样添加、移除、移动、复制、创建和查找节点?

        (1)创建新节点
          createDocumentFragment()    //创建一个DOM片段  oFragment.appendChild()
        	//DocumentFragments 是DOM节点。它们不是主DOM树的一部分。通常的用例是创建文档片段,将元素附加到文档片段,然后将文档片段附加到DOM树。在DOM树中,文档片段被其所有的孩子所代替。
      
          createElement()   //创建一个具体的元素
          createTextNode()   //创建一个文本节点
        (2)添加、移除、替换、插入
          appendChild()
          removeChild()
          replaceChild()
          insertBefore() //在已有的子节点前插入一个新的子节点
        (3)查找
          getElementsByTagName()    //通过标签名称
          getElementsByName()    //通过元素的Name属性的值(IE容错能力较强,会得到一个数组,其中包括id等于name值的)
          getElementById()    //通过元素Id,唯一性
      
    • .call() 和 .apply() 的区别?apply:应用某一对象的一个方法,用另一个对象替换当前对象。例如:B.apply(A, arguments);即A对象应用B对 象的方法。call:调用一个对象的一个方法,以另一个对象替换当前对象。例如:B.call(A, args1,args2);即A对象 调用B对象的方法。

      • apply:最多只能有两个参数——新this对象和一个数组argArray。

      • call:它可以接受多个参数,第一个参数与apply一样,后面则是一串参数列表。

         例子中用 add 来替换 sub,add.call(sub,3,1) == add(3,1) ,所以运行结果为:alert(4);
        
         注意:js 中的函数其实是对象,函数名是对 Function 对象的引用。
        
           function add(a,b)
           {
               alert(a+b);
           }
        
           function sub(a,b)
           {
               alert(a-b);
           }
        
           add.call(sub,3,1);
        
    • 数组和对象有哪些原生方法,列举一下?

      Array :

      • 1, sort
      • 2, slice
      • 3, forEach() 返回undefinded currentValue index array
      • 4, map() 方法创建一个新数组,其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
      • 5, concat join push pop shift unshift toString splice

      Object:

      • 1, toString

      • 2, ValueOf

      • 3, defineProperty

      • 4, assign: Object.assign(target, ...sources) Object.assign() 方法用于将所有可枚举的属性的值从一个或多个源对象复制到目标对象。它将返回目标对象。

      • 5, create: Object.create() 方法使用指定的原型对象和其属性创建了一个新的对象。Object.create(proto, [ propertiesObject ])

        proto:一个对象,应该是新创建的对象的原型。propertiesObject:可选。该参数对象是一组属性与值

        o2 = Object.create({}, { p: { value: 42, writable: true, enumerable: true, configurable: true } });

    • JS 怎么实现一个类。怎么实例化这个类

      可以通过构造函数模式,原型模式,混合模式等实现一个类,用 new 来实例化

          function Human(name){
           this.name = name;
          }
    
          var wangxiaoer = new Human('王小二');   
      对象可以通过 new Object(), Object.create() 方法, 或者使用字面 标记 (初始化 标记)初始化。 对象初始化,
        由花括号{}包含的一个由0个或者多个对象属性名和关联值组成的列表构成。
    
    • JavaScript中的作用域与变量声明提升?

    作用域:只会对某个范围产生作用,而不会对外产生影响的封闭空间。在这样的一些空间里,外部不能访问内部变量,但内部可以访问外部变量。js 存在声明提升:

    所有声明明都会被提升到作用域的最顶上  包括ES5的var、function,和ES6的function *、let、const、class
    但ES6 let const 等声明命令改变了语法行为,它所声明的变量一定要在声明后使用,否则报错。暂时性死区
    
    函数声明的优先级优于变量申明,且函数声明会连带定义一起被提升
    函数提升有两种,1 函数声明 整个函数提升 2函数表达式 只有变量提升,还是undefinded
    
    • 如何编写高性能的Javascript?

      参考文章

      • 1, 垃圾回收方面:
        • 手动消除引用(设置为null 比 delete 略好)
        • 解绑无用的事件监听器
        • 避免大量不被重用的数据被存储 缓存文章
      • 2, 函数方面:
        • 减少闭包 定时器 等
        • 使用时间代理委托 DocumentFragment
        • 不要使函数体积过大,确保函数职责单一,即确保变量使用相同类型,如不要add(1,2),add('a','b');
      • 3, 使用数组技巧:
        • 一般情况下不要删除数组元素
        • 使用数组字面量 var a = [];
        • 存储单一类型
        • 稀疏数组访问速度远远慢于满数组
      • 4, 避免内存泄漏:
        • 单页面应用的内存管理,特别移动端单页应用,基本不刷新页面, 遵循的标准规则来管理JavaScript中的内存,当元素被移除时,清理监听器
        • 减少回流与重绘
      • 5, 使用HTTP的缓存去减少资源的加载。
    • 那些操作会造成内存泄漏?

      参考资料

      内存泄漏可以定义为:应用程序不再需要占用内存的时候,由于某些原因,内存没有被操作系统或可用内存池回收。

      垃圾回收机制:标记清除法,引用计数法

      • 1, 闭包 (去除,造成内存泄露是浏览器的bug,不关闭包的事情,跟闭包和内存泄露有关系的地方是,使用闭包的同时比较容易形成循环引用,如果闭包的作用域链中保存着一些DOM节点,这时候就有可能造成内存泄露。链接

      • 2, 定时器 setInterval用完要clearInterval ,不然回调函数等内存无法回收。

      • 3, 全局变量,因为挂在window上面,window是不会被清空(在 JavaScript 文件头部加上 'use strict',可以避免此类错误发生。启用严格模式解析 JavaScript ,避免意外的全局变量,如函数里面用this,然后全局执行的变量。)

      • 4, 监听器 老版本的 IE 是无法检测 DOM 节点与 JavaScript 代码之间的循环引用,会导致内存泄漏。如今,现代的浏览器(包括 IE 和 Microsoft Edge)使用了更先进的垃圾回收算法,已经可以正确检测和处理循环引用了。换言之,回收节点内存时,不必非要调用 removeEventListener 了。

      • 5, 脱离Dom的引用。有时,保存dom的数据结构很有用把dom存成json或数组很有意义,但是,当你决定删除元素时,这些引用也需要同时删除。此外还需考虑DOM树内或子节点的引用问题,加入你的js代码保存了一个td的引用,但你决定删除整个表格的时候,整个表格还是会存在内存中的,因为td 是表格的子节点,子元素与父元素是引用关系,导致表格无法释放。

    • 闭包应用

      参考资料

      • 1, 函数柯里化

           ```javascript
                  var doSomething = function(do,something){
                 	 console.log(do+','+something);
                  }
                  function Curry(fn){
                 	 var stored_args = Array.prototype.slice.call(arguments,1);
                 	 return function (){
                 		 var new_args = Array.prototype.slice.call(arguments),
                 				 args = stored_args.concat(new_args);
                 				 return fn.call(null,args);
                 	 };
                  }
        
                  var newDoSomething  = Curry(doSomething,'hello');
                  newDoSomething('Howard');
                  newDoSomething('Harden');
        
      • 2, 单例模式

          ```javascript
                var getSingleInstance = (function(){
           	   	 function China () {
           	   		 this.name = "China";
           	   	 }
           	   	 var instance  = new China();
           	   	 return function () {
           	   		 return instance;
           	   	 }
           	    }());
            ```
        
    • 快速排序算法

      快速排序的核心就是选定一个哨兵,然后把它作为标准,对数据进行操作,把小的放前面,把大的放后面。然后执行这个过程若干次,就得到了最终的结果。算法过程中也实现了分治法的思想,即把复杂的模块分成几个简单的模块,分而治之。

      资料:(按顺序阅读比较容易理解)> 参考资 料1> 参考资料2

      someOther> 算法可视化网站:

    • JQuery的源码看过吗?能不能简单概况一下它的实现原理?

      JQuery、JQuery对象、DOM对象三者之间的关系是: JQuery是个工厂方法,用来构造JQuery对象; JQuery对象是个类数组对象,里面存储了DOM对象;实现原理

      • 1, 通过闭包函数避免污染全局变量
      • 2, jQuery.extend可以扩展jQuery,而jQuery.fn.extend可以扩展jQuery对象。
    • jQuery.fn的init方法返回的this指的是什么对象?为什么要返回this?

              	jQuery = function( selector, context ) {
              			return new jQuery.fn.init( selector, context, rootjQuery );
              	},
              	jQuery.fn = jQuery.prototype = { //fn即对应prototype
              		 constructor: jQuery,
              		 init: function( selector, context, rootjQuery ) {
              				...
              				return this;
              		 }
              		 ...
              	}
              	jQuery.fn.init.prototype = jQuery.fn;

      JQuer.fn.init方法返回this为JQ原型对象实例(如果没有选择器参数为空就是JQ原型对象,可以看jq源码,ctrl+f搜索jQuery.fn看其具体实现,你就会秒懂了),是一个类数组对象。

      因为Jq实现了$()来实例化jq对象,通过jq原型上init构造方法去实例化并返回一个对象,这样就可以不用new的方式去创建JQ对象,而且JQuery构造函数就相当于一个工厂函数。并且,为什么构造函数为什么要 new jQuery.fn.init(),这是因为如果直接利用init函数return出来的对象,会直接暴露了jQuery.prototype原型对象出去 参考,这样就可能让jQuery.prototype的受到破坏或被方法被覆盖了。这样我们就需要用new 关键字新建一个对象,改变this的指向对象,从而避开jQuer.fn的直接暴露。

      new 关键字的作用是创建一个对象,当一个函数使用 new 来调用的时候其实际上进行了下面的几个步骤:

      • 1, 创建一个空对象 obj
      • 2, 将这个 obj 的 proto 即:obj.proto 指向该函数的原型
      • 3, 执行该函数,并将函数中的 this 映射为 该空对象 obj。
      • 4, 最后如果该函数有返回值,而且返回值是对象,那么就返回这个对象。如果没有返回值,或者返回值不是对象,那么 new 的结果就是上面步骤构造出来的对象 obj。

      明白了 new 关键字的作用,也就明白了 new jQuery.prototype.init(selector,context); 的结果是 init.prototype 对象。(注意任何函数都有其原型对象)

      但是这也会带来一个问题,new jQuery.fn.init()所返回的新对象并没有继承jQuery.fn,因为jQuery.fn.init.prototype继承的是Object.prototype,并不包含jQuery.fn。这里的解决方法就是将 init.prototype 直接指向 jQuery.prototype。这下构造出来的对象就可以访问到 jQuery.prototype 中的内容了:在jq源码中就有这么一句

      	jQuery.fn.init.prototype = jQuery.fn;

      参考资料:

      • 1 Link1
      • 2 Link2 (解释不是很清楚)
      • 3 link3(第二配合第三来看)
    • jquery中如何将数组转化为json字符串,然后再转化回来?

             // JSON RegExp
             rvalidchars = /^[\],:{}\s]*$/,
             rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
             rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
             rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
      
            	parseJSON: function( data ) {
            	if ( window.JSON && window.JSON.parse ) {
            		return window.JSON.parse( data );
            	}
      
            	if ( data === null ) {
            		return data;
            	}
      
            	if ( typeof data === "string" ) {
      
            		// Make sure leading/trailing whitespace is removed (IE can't handle it)
            		data = jQuery.trim( data );
      
            		if ( data ) {
            			// Make sure the incoming data is actual JSON
            			// Logic borrowed from http://json.org/json2.js
            			if ( rvalidchars.test( data.replace( rvalidescape, "@" )
            				.replace( rvalidtokens, "]" )
            				.replace( rvalidbraces, "")) ) {
      
            				return ( new Function( "return " + data ) )();
            			}
            		}
            	}
      
            	jQuery.error( "Invalid JSON: " + data );
            	},

      jq会检查浏览器是否支持window.JSON.parse,支持的话就调用,不支持的话就正则匹配是否满足某些条件,然后把整个data返回。这里注意new Function()的使用,为什么不使用eval()呢?其实两个有一些作用域上的区别,eval函数可以访问到使用时局部环境变量。而new Function()只能在全局上起作用,而且new Function运行略优于eval,但是两个都是存在风险的,都可能运行json字符串里面违法的代码,应尽可能避免使用,因为ES5的严格模式这两种都是不允许的

      链接

       数组编程字符串可用Array.toString(),或者谁用Array.join(",") join() 方法用于把数组中的所有元素放入一个字符串。
      
    • jQuery 的属性拷贝(extend)的实现原理是什么,如何实现深拷贝?

      我们在 jQuery 中可以通过添加一个参数来实现递归extend。调用$.extend(true, {}, obj)实现原理就是遇到基本值就直接复制,遇到对象就递归调用extend进行深度拷贝。

          深复制:
         	 function deepCopy(source){
         		 var arr = {};
         		for(key in  source){
         			arr[key] = typeof key === 'Object' ? copy(source[key]):source[key];
         		}
         		return arr;
         	 }
          浅复制:
         	 function shallowCopy(source) {
         			var arr = {};
         			for(var temp in source ){
         				 if(source.hasOwnproperty[temp]){
         					 arr[temp] = source[temp];
         				 }
         			}
         			 return arr;
         	 }

      深入剖析 JavaScript 的深复制

    • jquery.extend 与 jquery.fn.extend的区别?

      • jquery.extend 为jquery类添加类方法,可以理解为添加静态方法
      • jquery.fn.extend:源码中jquery.fn = jquery.prototype,所以对jquery.fn的扩展,就是为jquery类添加成员函数

      使用:

      jquery.extend扩展,需要通过jquery类来调用,而jquery.fn.extend扩展,所有jquery实例都可以直接调用。

    • jQuery ready与load谁先执行?

      ready先执行,load后执行。

      DOM文档加载的步骤:

      • 1, 解析HTML结构。
      • 2, 加载外部脚本和样式表文件。
      • 3, 解析并执行脚本代码。
      • 4, 构造HTML DOM模型。//ready
      • 5, 加载图片等外部文件。
      • 6, 页面加载完毕。//load
    • jQuery 的队列是如何实现的?队列可以用在哪些地方?

      所以队列的本质是利用Array的push和shift来完成先进先出(First In First Out)

      队列是一种特殊的线性表,只允许在表的前端(队头)进行删除操作(出队),在表的后端(队尾)进行插入操作(入队)。队列的特点是先进先出(FIFO-first in first out),即最 先插入的元素最先被删除。您可以使用push,pop,unshift,shift来处理队列。您可以通过调用.queue()将功能添加到队列中,并使用.dequeue()删除(通过调用)函数。

      队列可以用在动画中,ajax等。

    • 谈一下Jquery中的bind(),live(),delegate(),on()的区别?

      参考资料1参考资料2

      • 1, bind()
        • 优点:直接绑定到元素上 .click() . hover() 都是利用bind()方法,这个方法可以很快就绑定上事件,而且很快执行回调,因为是对当个元素($()选取元素操作)而且对浏 览器的兼容性做了处理
        • 缺点:1当元素很多的时候,会有性能问题,2,而且不能对动态增加元素进行自绑定事件,3,当页面加载完才能进行绑定
      • 2, live()
        • 优点:利用事件委托,将事件绑定到到document,利用事件冒泡,jQuery查找选择器,再查找对应回调函数处理,绑定事件减少消耗
        • 缺点:1执行比较慢,从1.7已经不推荐了
      • 3, delegate()
        • 优点:是Live升级版,由你决定绑定元素
        • 缺点:同live,不过因为由我们控制绑定元素,所以比live 好一些。
      • 4, on() 以上三种都是通过on来实现的,可用on()代替。
    • 是否知道自定义事件。jQuery里的fire函数是什么意思,什么时候用?

      所谓自定义事件,就是有别于有别于带有浏览器特定行为的事件(类似click, mouseover, submit, keydown等事件),事件名称可以随意定义,可以通过特定的方法(jq trigger triggerHandler )进行添加,触发以及删除。

      callbacks.fire() 函数用于传入指定的参数调用所有的回调。此方法返回一个回调对象到它绑定的回调列表。用于触发$.Callbacks 回调队列函数。

      jQuery的自定义事件是通过on和one绑定的,然后再通过trigger来触发这个事件

    • jQuery 是通过哪个方法和 Sizzle 选择器结合的?(jQuery.fn.find()进入Sizzle)

      jQuery.find = Sizzle;

    • Jquery与jQuery UI 有啥区别?

      • jQuery是一个js库,主要提供的功能是选择器,属性修改和事件绑定等等。

      • jQuery UI则是在jQuery的基础上,利用jQuery的扩展性,设计的插件。提供了一些常用的界面元素,诸如对话框、拖动行为、改变大小行为等等

    • jQuery和Zepto的区别?各自的使用场景?

      jQuery是用在PC端上的框架,比较大,兼容性也比较好。而Zepto最初是为移动端开发的库,是jQuery的轻量级替代品,因为它的API和jQuery相似,而文件更小。并且多了一些移动端的触摸交互事件。

    • 针对 jQuery 的优化方法?

      参考资料

      • 基于Class的选择性的性能相对于Id选择器开销很大,因为需遍历所有DOM元素。

      • 频繁操作的DOM,先缓存起来再操作。用Jquery的链式调用更好。比如:var str=$("a").attr("href");

      • for (var i = size; i < arr.length; i++) {}for 循环每一次循环都查找了数组 (arr) 的.length 属性,在开始循环的时候设置一个变量来存储这个数字,可以让循环跑得更快:for (var i = size, length = arr.length; i < length; i++) {}

    • Zepto的点透问题如何解决?

      参考资料1参考资料2

      问题现象:

      在项目中,遇到的问题是有一个弹出层, 弹出层有一个按钮点击之后表示操作完成并且隐藏遮罩与弹出框,但是点击按钮之后弹出层下面的元素却触发了 click 事件,导致 bug 的出现.

      解决方法:

      • 1, 在遮罩之后加一个透明的 div 在 350ms 后消失
      • 2, 遮罩使用动画在 350ms 后消失
      • 3, 使用 CSS3 pointer-events:none 在 tap 事件触发的时候, 将下层元素添加一个属性 poniter-events 为 none, 然后下层元素就不会响应 click 事件了,然后设置一个定时器在, tap事件响应后的400ms 后将 pointer-events 设置为 auto 恢复正常.
      • 4, 使用 fastclick
      • 5, 直接将上层元素的tap事件换成click事件(会出现300ms的延迟触发事件)链接:
    • zepto为何不使用e.preventDefault()来解决穿透问题?

      因为zepto的tap事件统一是在document的touchend时触发的,若在这里使用e.preventDefault(),那页面上所有元素在touchend后触发的事件都不会被执行了。

      // 另外一种说法:贺师俊老师说的:就是当初手机浏览器的实现太挫了——为了兼容而模拟鼠标事件,但模拟的鼠标事件在网页的userland代码里是无法被preventDefault从dom的角度来说比较合理的应该是当我已经监听touchxxx事件(或退一步说,如果对touchxxx事件preventDefault之后)就不再出现模拟鼠标事件——但是当时webkit的c++程水平有点差,不知道应该这样做,所以就产生了很难消除的额外的click。

    • jQueryUI如何自定义组件?

    • 需求:实现一个页面操作不会整页刷新的网站,并且能在浏览器前进、后退时正确响应。给出你的技术实现方案?

    • 如何判断当前脚本运行在浏览器还是node环境中?(阿里)

        this === window ? 'browser' : 'node';
      
        通过判断Global对象是否为window,如果不为window,当前脚本没有运行在浏览器中
      
    • 移动端最小触控区域是多大?

      ISO和ANSI标准都推荐0.75" x 0.75"(约19 x 19毫米)的尺寸,来自莱特州立大学心理系的一项研究也表明0.75" x 0.75"的按钮对于用户来说是满意率最高的。

      参考资料

    • jQuery 的 slideUp动画 ,如果目标元素是被外部事件驱动, 当鼠标快速地连续触发外部元素事件, 动画会滞后的反复执行,该如何处理呢?

      jquery stop(): 如:$("#div").stop(stopAll,goToEnd).animate({width:"100px"},100);

    • 把 Script 标签 放在页面的最底部的body封闭之前和封闭之后有什么区别?浏览器会如何解析它们?

      按照HTML5标准中的HTML语法规则,如果在后再出现

    • 移动端的点击事件的有延迟,时间是多久,为什么会有? 怎么解决这个延时?

      (click 有 300ms 延迟,为了实现safari的双击事件的设计,浏览器要知道你是不是要双击操作。)

      解决方法:

      • 1, 设置不能缩放:user-scalable=no。 不能缩放就不会有双击缩放操作,因此click事件也就没了300ms延迟,这个是Chrome首先在Android中提出的。

      • 2, 设置显示宽度:width=device-width。Chrome 开发团队不久前宣布,在 Chrome 32 这一版中,他们将在包含 width=device-width 或者置为比 viewport 值更小的页面上禁用双击缩放。当然,没有双击缩放就没有 300 毫秒点击延迟。

      • 3, IE的指针事件 (Pointer Events):设置touch-action:none,根据规范,touch-action属性决定 “是否触摸操作会触发用户代理的默认行为。这包括但不限于双指缩放等行为”。从实际应用的角度来看,touch-action决定了用户在点击了目标元素之后,是否能够进行双指缩放或者双击缩放。因此,这也相当完美地解决了 300 毫秒点击延迟的问题。

        鉴于上述的3种解决方案,现在较为通用的meta设置为:

        <meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no">
      • 4, 指针事件的 polyfill

      • 5, FastClick

    • 知道各种JS框架(Angular, Backbone, Ember, React, Meteor, Knockout...)么? 能讲出他们各自的优点和缺点么?

    • Underscore 对哪些 JS 原生对象进行了扩展以及提供了哪些好用的函数方法?

      Underscore 并没有在JS原生对象上进行扩展,而是类似于jq一样封装在一个自定义对象中

      • throttle
      • debounce
    • JQuery一个对象可以同时绑定多个事件,这是如何实现的?

    源码:

    ```javascript
            on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
    	     // Types can be a map of types/handlers
    			var type, origFn;
    			if ( typeof types === "object" ) {
    				// ( types-Object, selector, data )
    				if ( typeof selector !== "string" ) {
    					// ( types-Object, data )
    					data = data || selector;
    					selector = undefined;
    				}
    				for ( type in types ) {
    					this.on( type, selector, data, types[ type ], one );
    				}
    				return this;
    			}
    
    			if ( data == null && fn == null ) {
    				// ( types, fn )
    				fn = selector;
    				data = selector = undefined;
    			} else if ( fn == null ) {
    				if ( typeof selector === "string" ) {
    					// ( types, selector, fn )
    					fn = data;
    					data = undefined;
    				} else {
    					// ( types, data, fn )
    					fn = data;
    					data = selector;
    					selector = undefined;
    				}
    			}
    			if ( fn === false ) {
    				fn = returnFalse;
    			} else if ( !fn ) {
    				return this;
    			}
    
    			if ( one === 1 ) {
    				origFn = fn;
    				fn = function( event ) {
    					// Can use an empty set, since event contains the info
    					jQuery().off( event );
    					return origFn.apply( this, arguments );
    				};
    				// Use same guid so caller can remove using origFn
    				fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
    			}
    			return this.each( function() {
    				jQuery.event.add( this, types, fn, data, selector );
    			});
    			},
    ```
    
    * 1, 多个事件同一个函数:
    
       ```javascript
       	   $("div").on("click mouseover", function(){});
       ```
    
    * 2, 多个事件不同函数
    
    	```javascript
    	    $("div").on({
    	    	click: function(){},
    	    	mouseover: function(){}
    	    });
        ```
    
    • Node.js的适用场景?

      Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境。 Node.js 使用了一个事件驱动、非阻塞式 I/O 的模型,使其轻量又高效。因为Node处理并发能力比较强,处理高并发的能力基于其的事件驱动模式,通过异步回调,非阻塞I/O控制事件执行过程,当多个请求发生,主线程并不会阻塞等回应,而是继续执行下去,通过异步回调加入事件队列,再执行,所以比传统的多线程,线程池模式能更好的处理高并发。

      传统的适用于(并发)异步处理相对较少,后台计算量大,后台业务逻辑复杂的应用程序。

      但是也有比较大的缺点就是如果有长时间的计算(大循环),将导致CPU不能释放 ,使得后续IO无法发起。

      使用场景;处理数万条连接,本身没有过多的逻辑运算(或者逻辑运算由客户端完成),只需要请求API,组织数据返回即可。实时消息推送 ,实时聊天、客户端逻辑强大的单页APP

      Nodejs优缺点及适用场景

      从原理上理解Nodejs

    • (如果会用node)知道route, middleware, cluster, nodemon, pm2, server-side rendering么?

      route路由 对url的处理就叫做路由 路由用于确定应用程序如何响应对特定端点的客户机请求,包含一个 URI(或路径)和一个特定的 HTTP 请求方法(GET、POST 等)。每个路由可以具有一个或多个处理程序函数,这些函数在路由匹配时执行。

      middleware:

      知乎.Node.js 的中间件是用来做什么的

      中间件是什么?

      Express 是一个自身功能极简,完全是由路由和中间件构成一个的 web 开发框架:从本质上来说,一个 Express 应用就是在调用各种中间件。

      cluster是一个nodejs内置的模块,用于nodejs多核处理。cluster模块,可以帮助我们简化多进程并行化程序的开发难度,轻松构建一个用于负载均衡的集群。

      nodemon监控 NodeJS 源代码的任何变化和自动重启你的服务器

      pm2 是一个带有负载均衡功能的Node应用的进程管理器

      server-side rendering 服务端渲染

    • 解释一下 Backbone 的 MVC 实现方式?

    • 什么是“前端路由”?什么时候适合使用“前端路由”? “前端路由”有哪些优点和缺点?

      路由是根据不同的 url 地址展示不同的内容或页面

      前端路由:就是把不同路由对应不同的内容或页面的任务交给前端来做,之前是通过服务端根据 url 的不同返回不同的页面实现的。

      后端路由:每跳转到不同的URL,都是重新访问服务端,然后服务端返回页面,页面也可以是服务端获取数据,然后和模板组合,返回HTML,也可以是直接返回模板HTML,然后由前端js再去请求数据,使用前端模板和数据进行组合,生成想要的HTML。

      前端路由更多用在单页应用上, 也就是SPA, 因为单页应用, 基本上都是前后端分离的, 后端自然也就不会给前端提供路由。

      优点:

        1. 从性能和用户体验的层面来比较的话,后端路由每次访问一个新页面的时候都要向服务器发送请求,然后服务器再响应请求,这个过程肯定会有延迟。而前端路由在访问一个新页面的时候仅仅是变换了一下路径而已,没有了网络延迟,对于用户体验来说会有相当大的提升。
        1. 在某些场合中,用ajax请求,可以让页面无刷新,页面变了但Url没有变化,用户就不能复制到想要的地址,用前端路由做单页面网页就很好的解决了这个问题

      缺点:使用浏览器的前进,后退键的时候会重新发送请求,没有合理地利用缓存

      前端路由的两种实现方法

      • 1 history.pushState 和 history.replaceState popState
        • 2 监听hashchange事件
    • 知道什么是webkit么? 知道怎么用浏览器的各种工具来调试和debug代码么?

        Chrome,Safari浏览器内核。
      
    • 如何测试前端代码么? 知道BDD, TDD, Unit Test么? 知道怎么测试你的前端工程么(mocha, sinon, jasmin, qUnit..)?

    • 前端templating(Mustache, underscore, handlebars)是干嘛的, 怎么用?

      模板引擎就像是html的解析生成器,将对应的模板填充完数据之后生成静态的html页面。它可以在浏览器端(比如angular中指令所用的模板)也可以在服务器端执行,不过一般用于服务器端。因为它的一个作用是抽象公共页面来重用,如果在服务端填充数据,可以减少回填数据给页面的ajax请求,从而提升浏览器端整体页面渲染速度。

    • 简述一下 Handlerbars 与 angular 或者 vue 这些(静态模板与动态模板的区别)?

      静态模板是预先写个界面模板,然后通过数据填充,生成字符串,添加到页面中。当被添加到页面后,无论数据如何变化,界面也不再改变,除非再一次compile();动态模板不仅仅有界面模板,还拥有一系列配置,这些配置能被特殊方式解析,从而与数据进行关联,动态变化。

    • 简述一下 Handlebars 的基本用法?

      A Beginner’s Guide to Handlebars

      • 1, 编写模板

              <script id="handlebars-demo" type="text/x-handlebars-template">
         	    <div>
         	    	My name is {{name}}. I am a {{occupation}}.
         	    </div>
              </script>
          ```
      • 2, 运行时编译模板,使用Handlebars.compile()编译,将会返回一个函数(或者预编译模板。这样的话,就只需要一个更小的运行时库文件,并且对性能来说是一个极大的节约)

      • 3,然后通过将数据作为参数来执行此功能。执行完成后,该函数返回所需的HTML,并将所有变量替换为相应的值。

      • 4,将html 片段注入到网页中

        示例:

          	    // Retrieve the template data from the HTML (jQuery is used here).
          	    var template = $('#handlebars-demo').html();
        
          	    // Compile the template data into a function
          	    var templateScript = Handlebars.compile(template);
        
          	    var context = { "name" : "Ritesh Kumar", "occupation" : "developer" };
        
          	    // html = 'My name is Ritesh Kumar. I am a developer.'
          	    var html = templateScript(context);
        
          	    // Insert the HTML code into the page
          	    $(document.body).append(html);
          	```
        

      优点:

      • 1, 模板语言简单。继承自mustache,用{{content}}标记出要替换的内容即可。
      • 2, 包含逻辑判断和循环。在mustache基础上加强了这个部分,使得代码更易读。
      • 3, 不支持复杂的逻辑,尤其是嵌套JS。我认为这是模板引擎的关键,任何复杂的逻辑放在表现层都会使得系统不稳定。
      • 4, 支持预编译。可以加快实际运行的速度。
      • 5, 提供扩展功能,可以方便地增加自定义功能。这也是本文重点。
    • 简述一下 Handlerbars 的对模板的基本处理流程,如何编译的?如何缓存的?

      • 1, Handlebars把包含变量的模板编译成一个函数
      • 2, 然后通过传递JSON对象作为参数来执行此功能。这个JSON对象被称为上下文,它包含模板中使用的变量的值
      • 3,在执行时,该函数在将模板的变量替换为相应的值后返回所需的HTML
    • 用js实现千位分隔符?(来源:前端农民工,提示:正则+replace)

      参考:

        ```javascript
        	function commafy(num) {
        		 return num && num
        		    .toString()
        			.replace(/(\d)(?=(\d{3})+\.)/g, function($0, $1) {
        				return $1 + ",";
        			});
            }
             console.log(commafy(1234567.90)); //1,234,567.90
        ```
      
    • 检测浏览器版本有哪些方式?

      功能检测、userAgent特征检测navigator 对象

      比如:

      • navigator.appName:保存浏览器类型
      • navigator.appVersion:存有浏览器的版本信息
      • navigator.userAgent: 浏览器的用户代理报头//"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_2) AppleWebKit/537.36(KHTML, like Gecko) Chrome/41.0.2272.101 Safari/537.36"
    • What is a Polyfill?

      一个shim是一个库,它将一个新的API引入到一个旧的环境中,而且仅靠旧环境中已有的手段实现;polyfill 是 shim 的一种。

      polyfill 是“在旧版浏览器上复制标准 API 的 JavaScript 补充”,可以动态地加载 JavaScript 代码或库,在不支持这些标准 API 的浏览器中模拟它们。

        例如,geolocation(地理位置)polyfill 可以在 navigator 对象上添加全局的 geolocation 对象,
        还能添加 getCurrentPosition 函数以及“坐标”回调对象,所有这些都是 W3C 地理位置 API 定义的对象和函数。
        因为 polyfill 模拟标准 API,所以能够以一种面向所有浏览器未来的方式针对这些 API 进行开发,
        一旦对这些 API 的支持变成绝对大多数,则可以方便地去掉 polyfill,无需做任何额外工作。
      
    • 做的项目中,有没有用过或自己实现一些 polyfill 方案(兼容性处理方案)?

        比如: html5shiv、Geolocation、Placeholder
      
    • 我们给一个dom同时绑定两个点击事件,一个用捕获,一个用冒泡。会执行几次事件,会先执行冒泡还是捕获?

      会执行两次事件,按绑定先后顺序执行。如果父子元素绑定事件,绑定捕获的先执行于冒泡的。

    • 使用JS实现获取文件扩展名?

        function getFileExtension(filename) {
        	return filename.slice((filename.lastIndexOf(".") >>> 0) + 1);
        }
    	String.lastIndexOf() 方法返回指定值(本例中的'.')在调用该方法的字符串中最后出现的位置,如果没找到则返回 -1。
    	对于'filename'和'.hiddenfile',lastIndexOf的返回值分别为0和-1无符号右移操作符(»>) 将-1转换为4294967295,
    	将-2转换为4294967294,这个方法可以保证边缘情况时文件名不变。
    	String.prototype.slice() 从上面计算的索引处提取文件的扩展名。如果索引比文件名的长度大,结果为""。
    

    ECMAScript6 相关

    • Object.is() 与原来的比较操作符“ ===”、“ ==”的区别?

    两等号判等,会在比较时进行类型转换;

    三等号判等(判断严格),比较时不进行隐式类型转换,(类型不同则会返回false);

    Object.is 在三等号判等的基础上特别处理了 NaN 、-0 和 +0 ,保证 -0 和 +0 不再相同,

    但 Object.is(NaN, NaN) 会返回 true.

    Object.is 应被认为有其特殊的用途,而不能用它认为它比其它的相等对比更宽松或严格。

    前端框架相关

    • react-router 路由系统的实现原理?

      • 1 > 深入理解 react-router 路由系统
      • 2 > react-router的实现原理

      没有学过react,但猜想应该都是采用hasn 或者H5 history等路由监听方法来进行封装引用的。

    • React中如何解决第三方类库的问题?

      因为学过VUE ,所以给出vue的方案

      • 1 全局变量 (不适合服务端)
      • 2 在每个文件中手动引用(缺点繁琐)
      • 3 代理到 Vue 的原型对象上

    其他问题

    • 原来公司工作流程是怎么样的,如何与其他人协作的?如何夸部门合作的?

      流程:

      • 1, 与后台沟通接口文档
      • 2, 使用原型软件设计原型
      • 3, 进行开发
      • 4, 后期测试
      • 5,部署上线
    • 你遇到过比较难的技术问题是?你是如何解决的?

    • 设计模式 知道什么是singleton, factory, strategy, decrator么?

      Learning JavaScript Design Patterns

      javascript 设计模式(文章很长,请自备瓜子,水果和眼药水)

      汤姆大叔深入理解JavaScript系列

      singleton:

           var singleton = function() {
          	 var instance;
          	 var createInstance = function() {
          		 this.a = 1;
          		 this.b = 2;
          	 };
          	 return {
          		 getInstance: function() {
          			 if (!instance) {
          				 instance = new createInstance();
          			 }
          			 return instance;
          		 }
          	 }
           }
           var Factory = singleton()
           var singleton_1 = Factory.getInstance();

      很棒的实例

      factory

            // A constructor for defining new cars
            function Car( options ) {
      
           	 // some defaults
           	 this.doors = options.doors || 4;
           	 this.state = options.state || "brand new";
           	 this.color = options.color || "silver";
      
            }
      
            // A constructor for defining new trucks
            function Truck( options){
      
           	 this.state = options.state || "used";
           	 this.wheelSize = options.wheelSize || "large";
           	 this.color = options.color || "blue";
            }
      
      
            // FactoryExample.js
      
            // Define a skeleton vehicle factory
            function VehicleFactory() {}
      
            // Define the prototypes and utilities for this factory
      
            // Our default vehicleClass is Car
            VehicleFactory.prototype.vehicleClass = Car;
      
            // Our Factory method for creating new Vehicle instances
            VehicleFactory.prototype.createVehicle = function ( options ) {
      
           	 switch(options.vehicleType){
           		 case "car":
           			 this.vehicleClass = Car;
           			 break;
           		 case "truck":
           			 this.vehicleClass = Truck;
           			 break;
           		 //defaults to VehicleFactory.prototype.vehicleClass (Car)
           	 }
      
           	 return new this.vehicleClass( options );
      
            };
      
            // Create an instance of our factory that makes cars
            var carFactory = new VehicleFactory();
            var car = carFactory.createVehicle( {
           						 vehicleType: "car",
           						 color: "yellow",
           						 doors: 6 } );
         ```
      
      strategy
      
       decrator
      
    • 常使用的库有哪些?常用的前端开发工具?开发过什么应用或组件?

    • 页面重构怎么操作?

        网站重构:在不改变外部行为的前提下,简化结构、添加可读性,而在网站前端保持一致的行为。
        也就是说是在不改变UI的情况下,对网站进行优化,在扩展的同时保持一致的UI。
      
        对于传统的网站来说重构通常是:
      
        表格(table)布局改为DIV+CSS
        使网站前端兼容于现代浏览器(针对于不合规范的CSS、如对IE6有效的)
        对于移动平台的优化
        针对于SEO进行优化
        深层次的网站重构应该考虑的方面
      
        减少代码间的耦合
        让代码保持弹性
        严格按规范编写代码
        设计可扩展的API
        代替旧有的框架、语言(如VB)
        增强用户体验
        通常来说对于速度的优化也包含在重构中
      
        压缩JS、CSS、image等前端资源(通常是由服务器来解决)
        程序的性能优化(如数据读写)
        采用CDN来加速资源加载
        对于JS DOM的优化
        HTTP服务器的文件缓存
      
    • 列举IE与其他浏览器不一样的特性?

        1、事件不同之处:
      
           	触发事件的元素被认为是目标(target)。而在 IE 中,目标包含在 event 对象的 srcElement 属性;
      
        	获取字符代码、如果按键代表一个字符(shift、ctrl、alt除外),IE 的 keyCode 会返回字符代码(Unicode),
        	DOM 中按键的代码和字符是分离的,要获取字符代码,需要使用 charCode 属性;
      
        	阻止某个事件的默认行为,IE 中阻止某个事件的默认行为,必须将 returnValue 属性设置为 false,Mozilla 中,
        	需要调用 preventDefault() 方法;
      
        	停止事件冒泡,IE 中阻止事件进一步冒泡,需要设置 cancelBubble 为 true,Mozzilla 中,
        	需要调用 stopPropagation();
      
    • 99%的网站都需要被重构是那本书上写的?

        网站重构:应用web标准进行设计(第2版)
      
    • 什么叫优雅降级和渐进增强?

        优雅降级:Web站点在所有新式浏览器中都能正常工作,如果用户使用的是老式浏览器,则代码会针对旧版本的
        IE进行降级处理了,使之在旧式浏览器上以某种形式降级体验却不至于完全不能用。
        如:border-shadow
      
        渐进增强:从被所有浏览器支持的基本功能开始,逐步地添加那些只有新版本浏览器才支持的功能,向页面增加
        不影响基础浏览器的额外样式和功能的。当浏览器支持时,它们会自动地呈现出来并发挥作用。
        如:默认使用flash上传,但如果浏览器支持 HTML5 的文件上传功能,则使用HTML5实现更好的体验;
      
    • 是否了解公钥加密和私钥加密。

        一般情况下是指私钥用于对数据进行签名,公钥用于对签名进行验证;
        HTTP网站在浏览器端用公钥加密敏感数据,然后在服务器端再用私钥解密。
      
    • WEB应用从服务器主动推送Data到客户端有那些方式?

        html5提供的Websocket
        不可见的iframe
        WebSocket通过Flash
        XHR长时间连接
        XHR Multipart Streaming
        
                          
                          

      你可能感兴趣的:(理论基础)