专栏首页互联网杂技上一期前端面试题整理答案

上一期前端面试题整理答案

上期答案

1.盒子模型

在网页中,一个元素占有空间的大小由几个部分构成,其中包括元素的内容(content),元素的内边距(padding),元素的边框(border),元素的外边距(margin)四个部分。这四个部分占有的空间中,有的部分可以显示相应的内容,而有的部分只用来分隔相邻的区域或区域。4个部分一起构成了css中元素的盒模型。

2.关于元素

行内元素:a、b、span、img、input、strong、select、label、em、button、textarea

块级元素:div、ul、li、dl、dt、dd、p、h1-h6、blockquote

空元素:即系没有内容的HTML元素,例如:br、meta、hr、link、input、img

3.src与href

href 是指向网络资源所在位置,建立和当前元素(锚点)或当前文档(链接)之间的链接,用于超链接。

src是指向外部资源的位置,指向的内容将会嵌入到文档中当前标签所在位置;在请求src资源时会将其指向的资源下载并应用到文档内,例如js脚本,img图片和frame等元素。当浏览器解析到该元素时,会暂停其他资源的下载和处理,直到将该资源加载、编译、执行完毕,图片和框架等元素也如此,类似于将所指向资源嵌入当前标签内。这也是为什么将js脚本放在底部而不是头部。

4.px,em

px和em都是长度单位,区别是,px的值是固定的,指定是多少就是多少,计算比较容易。em得值不是固定的,并且em会继承父级元素的字体大小。

浏览器的默认字体高都是16px。所以未经调整的浏览器都符合: 1em=16px。那么12px=0.75em, 10px=0.625em

5.常见浏览器以及内核

IE: trident内核

Firefox:gecko内核

Safari:webkit内核

Opera:以前是presto内核,Opera现已改用Google Chrome的Blink内核

Chrome:Blink(基于webkit,Google与Opera Software共同开发)

6.dom节点基本操作

1)创建新节点

createDocumentFragment() //创建一个DOM片段
createElement() //创建一个具体的元素
createTextNode() //创建一个文本节点

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

appendChild() //添加
removeChild() //移除
replaceChild() //替换
insertBefore() //插入

3)查找

getElementsByTagName() //通过标签名称
getElementsByName() //通过元素的Name属性的值
getElementById() //通过元素Id,唯一性

7.cookies,sessionStorage,localStorage

sessionStorage用于本地存储一个会话(session)中的数据,这些数据只有在同一个会话中的页面才能访问并且当会话结束后数据也随之销毁。因此sessionStorage不是一种持久化的本地存储,仅仅是会话级别的存储。而localStorage用于持久化的本地存储,除非主动删除数据,否则数据是永远不会过期的。

web storage和cookie的区别

Web Storage的概念和cookie相似,区别是它是为了更大容量存储设计的。Cookie的大小是受限的,并且每次你请求一个新的页面的时候Cookie都会被发送过去,这样无形中浪费了带宽,另外cookie还需要指定作用域,不可以跨域调用。

除此之外,Web Storage拥有setItem,getItem,removeItem,clear等方法,不像cookie需要前端开发者自己封装setCookie,getCookie。但是Cookie也是不可以或缺的:Cookie的作用是与服务器进行交互,作为HTTP规范的一部分而存在 ,而Web Storage仅仅是为了在本地“存储”数据而生。

8.清除字符串前后空格

function trim(str) {
    if (str && typeof str === "string") {
        return str.replace(/(^\s*)|(\s*)$/g,""); //去除前后空白符
    }
}

9.数组去重

基本基于原型实现

Array.prototype.unique = function(){    var result = [];    this.forEach(function(v){        if(result.indexOf(v) < 0){            result.push(v);        }    });    return result;}

利用hash

Array.prototype.unique = function(){    var result = [],hash = {};    this.forEach(function(v){        var type = typeof(v);  //获取元素类型        hash[v] || (hash[v] = new Array());        if(hash[v].indexOf(type) < 0){            hash[v].push(type);  //存储类型            result.push(v);        }    });    return result;}

先排序后去重

Array.prototype.unique = function(){    var result = [this[0]];    this.sort();    this.forEach(function(v){        v != result[result.length - 1] && result.push(v);
     //仅与result最后一个元素比较    });}

10.快速排序

function quickSort(arr){    qSort(arr,0,arr.length - 1);}function qSort(arr,low,high){    if(low < high){        var partKey = partition(arr,low,high);        qSort(arr,low, partKey - 1);        qSort(arr,partKey + 1,high);    }}function partition(arr,low,high){    var key = arr[low];  //使用第一个元素作为分类依据    while(low < high){        while(low < high && arr[high] >= arr[key])            high--;        arr[low] = arr[high];        while(low < high && arr[low] <= arr[key])            low++;        arr[high] = arr[low];    }    arr[low] = key;    return low;}

快速排序实现方式2

function quickSort(arr){   if(arr.length <= 1) return arr;   var index = Math.floor(arr.length/2);   var key = arr.splice(index,1)[0];   var left = [],right = [];   arr.forEach(function(v){       v <= key ? left.push(v) : right.push(v);   });   return quickSort(left).concat([key],quickSort(right));}

11.js实现继承

js里常用的如下两种继承方式:

原型链继承(对象间的继承)
类式继承(构造函数间的继承)

由于js不像java那样是真正面向对象的语言,js是基于对象的,它没有类的概念。所以,要想实现继承,可以用js的原型prototype机制或者用applycall方法去实现

在面向对象的语言中,我们使用来创建一个自定义对象。然而js中所有事物都是对象,那么用什么办法来创建自定义对象呢?这就需要用到js的原型:

我们可以简单的把prototype看做是一个模版,新创建的自定义对象都是这个模版(prototype)的一个拷贝 (实际上不是拷贝而是链接,只不过这种链接是不可见,新实例化的对象内部有一个看不见的__Proto__指针,指向原型对象)。

js可以通过构造函数和原型的方式模拟实现类的功能。 另外,js类式继承的实现也是依靠原型链来实现的。

原型式继承与类式继承

类式继承是在子类型构造函数的内部调用超类型的构造函数。 严格的类式继承并不是很常见,一般都是组合着用:

function Super(){    this.colors=["red","blue"];
} 
function Sub(){
    Super.call(this);
}

原型式继承是借助已有的对象创建新的对象,将子类的原型指向父类,就相当于加入了父类这条原型链

原型链继承

为了让子类继承父类的属性(也包括方法),首先需要定义一个构造函数。然后,将父类的新实例赋值给构造函数的原型。代码如下:

<script>
    function Parent(){        this.name = 'mike';
    }    function Child(){        this.age = 12;
    }
    Child.prototype = new Parent();

    //Child继承Parent,通过原型,形成链条

    var test = new Child();
    alert(test.age);
    alert(test.name);//得到被继承的属性
    //继续原型链继承
    function Brother(){   //brother构造
        this.weight = 60;
    }
    Brother.prototype = new Child();//继续原型链继承
    var brother = new Brother();
    alert(brother.name);//继承了Parent和Child,弹出mike
    alert(brother.age);//弹出12</script>

以上原型链继承还缺少一环,那就是Object,所有的构造函数都继承自Object。而继承Object是自动完成的,并不需要我们自己手动继承,那么他们的从属关系是怎样的呢?

确定原型和实例的关系

可以通过两种方式来确定原型和实例之间的关系。操作符instanceofisPrototypeof()方法:

alert(brother instanceof Object)
//truealert(test instanceof Brother);
//false,test 是brother的超类

alert(brother instanceof Child);
//truealert(brother instanceof Parent);//true

只要是原型链中出现过的原型,都可以说是该原型链派生的实例的原型,因此,isPrototypeof()方法也会返回true

js中,被继承的函数称为超类型(父类,基类也行),继承的函数称为子类型(子类,派生类)。使用原型继承主要由两个问题: 一是字面量重写原型会中断关系,使用引用类型的原型,并且子类型还无法给超类型传递参数。

伪类解决引用共享和超类型无法传参的问题,我们可以采用“借用构造函数”技术

借用构造函数(类式继承)

<script>
    function Parent(age){        

    this.name = ['mike','jack','smith'];       

     this.age = age;
    }    

     function Child(age){
        Parent.call(this,age);
    }  

       var test = new Child(21);
    alert(test.age);//21
    alert(test.name);//mike,jack,smith
    test.name.push('bill');
    alert(test.name);//mike,jack,smith,bill</script>

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

组合继承

<script>
    function Parent(age){       

     this.name = ['mike','jack','smith'];     

        this.age = age;
    }
    Parent.prototype.run = function () {    

            return this.name  + ' are both' + this.age;
    };   
 function Child(age){
        Parent.call(this,age);//对象冒充,给超类型传参
    }
    Child.prototype = new Parent();//原型链继承
    var test = new Child(21);//写new Parent(21)也行
    alert(test.run());//mike,jack,smith are both21</script>

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

call()的用法:调用一个对象的一个方法,以另一个对象替换当前对象。

call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 

原型式继承

这种继承借助原型并基于已有的对象创建新对象,同时还不用创建自定义类型的方式称为原型式继承

<script>
     function obj(o){        
      function F(){}
         F.prototype = o;      
         return new F();
     }   
     var box = {
        name : 'trigkit4',
        arr : ['brother','sister','baba']
    };    
     var b1 = obj(box);
    alert(b1.name);//trigkit4
    b1.name = 'mike';
    alert(b1.name);//mike
    alert(b1.arr);//brother,sister,baba
    b1.arr.push('parents');
    alert(b1.arr);//brother,sister,baba,parents
    var b2 = obj(box);
    alert(b2.name);//trigkit4
    alert(b2.arr);//brother,sister,baba,parents
</script>

原型式继承首先在obj()函数内部创建一个临时性的构造函数 ,然后将传入的对象作为这个构造函数的原型,最后返回这个临时类型的一个新实例。

寄生式继承

这种继承方式是把原型式+工厂模式结合起来,目的是为了封装创建的过程。

<script>
    function create(o){        
    var f= obj(o);
    f.run = function () {            

    return this.arr;//同样,会共享引用
        };       

     return f;
    }

     
</script>

组合式继承的小问题

组合式继承是js最常用的继承模式,但组合继承的超类型在使用过程中会被调用两次;一次是创建子类型的时候,另一次是在子类型构造函数的内部

<script>
    function Parent(name){       

     this.name = name;       

    this.arr = ['哥哥','妹妹','父母'];
    }

    Parent.prototype.run = function () {        

    return this.name;
    };    function Child(name,age){
        Parent.call(this,age);//第二次调用
        this.age = age;
    }

    Child.prototype = new Parent();//第一次调用

</script>

以上代码是之前的组合继承,那么寄生组合继承,解决了两次调用的问题。

寄生组合式继承

<script>
    function obj(o){       
     function F(){}
        F.prototype = o;     return new F();
    }  
    function create(parent,test){      
        var f = obj(parent.prototype);//创建对象
        f.constructor = test;//增强对象
    }   
    function Parent(name){    
          this.name = name;    
          this.arr = ['brother','sister','parents'];
    }
    Parent.prototype.run = function () {    
       return this.name;
    };      function Child(name,age){
     Parent.call(this,name);     this.age =age;
    }
    inheritPrototype(Parent,Child);//通过这里实现继承
    var test = new Child('trigkit4',21);
    test.arr.push('nephew');alert(test.arr);//
    alert(test.run());//只共享了方法
    var test2 = new Child('jack',22);
    alert(test2.arr);//引用问题解决</script>

12.call和apply

全局函数applycall可以用来改变函数中this的指向,如下:

 // 定义一个全局函数
    function foo() {        console.log(this.fruit);
    }    
    // 定义一个全局变量
    var fruit = "apple";    // 自定义一个对象
    var pack = {
        fruit: "orange"
    };    
    // 等价于window.foo();
    foo.apply(window);  // "apple",此时this等于window
    // 此时foo中的this === pack
    foo.apply(pack);    // "orange"

13、你如何对网站的文件和资源进行优化?

期待的解决方案包括:
 文件合并
 文件最小化/文件压缩
 使用 CDN 托管
 缓存的使用(多个域名来提供缓存)
 其他

14.如何判断一个对象是否属于某个类?

使用instanceof

if(a instanceof Person){

alert('yes');

}

15、HTML与XHTML——二者有什么区别

区别:
1.所有的标记都必须要有一个相应的结束标记
2.所有标签的元素和属性的名字都必须使用小写
3.所有的XML标记都必须合理嵌套
4.所有的属性必须用引号""括起来
5.把所有<和&特殊符号用编码表示
6.给所有属性赋一个值
7.不要在注释内容中使“--”
8.图片必须有说明文字

16、关于Http 2.0 你知道多少?

HTTP/2引入了“服务端推(serverpush)”的概念,它允许服务端在客户端需要数据之前就主动地将数据发送到客户端缓存中,从而提高性能。 HTTP/2提供更多的加密支持 HTTP/2使用多路技术,允许多个消息在一个连接上同时交差。 它增加了头压缩(header compression),因此即使非常小的请求,其请求和响应的header都只会占用很小比例的带宽。

17、栈和队列的区别?

栈的插入和删除操作都是在一端进行的,而队列的操作却是在两端进行的。
队列先进先出,栈先进后出。
栈只允许在表尾一端进行插入和删除,而队列只允许在表尾一端进行插入,
在表头一端进行删除 

18、GET和POST的区别,何时使用POST?

GET:一般用于信息获取,使用URL传递参数,对所发送信息的数量也有限制,
一般在2000个字符
POST:一般用于修改服务器上的资源,对所发送的信息没有限制。

GET方式需要使用Request.QueryString来取得变量的值,而POST方式通过
Request.Form来获取变量的值,
也就是说Get是通过地址栏来传值,而Post是通过提交表单来传值。

然而,在以下情况中,请使用 POST 请求:
无法使用缓存文件(更新服务器上的文件或数据库)
向服务器发送大量数据(POST 没有数据量限制)
发送包含未知字符的用户输入时,POST 比 GET 更稳定也更可靠

19、js操作获取和设置cookie

//创建cookie
function setCookie(name, value, expires, path, domain, secure) {
    var cookieText = encodeURIComponent(name) + '=' + 
encodeURIComponent(value);
    if (expires instanceof Date) {
        cookieText += '; expires=' + expires;
    }
    if (path) {
        cookieText += '; expires=' + expires;
    }
    if (domain) {
        cookieText += '; domain=' + domain;
    }
    if (secure) {
        cookieText += '; secure';
    }
    document.cookie = cookieText;
}

//获取cookie
function getCookie(name) {
    var cookieName = encodeURIComponent(name) + '=';
    var cookieStart = document.cookie.indexOf(cookieName);
    var cookieValue = null;
    if (cookieStart > -1) {
        var cookieEnd = document.cookie.indexOf(';', cookieStart);
        if (cookieEnd == -1) {
            cookieEnd = document.cookie.length;
        }
        cookieValue = decodeURIComponent(
document.cookie.substring(cookieStart + 
cookieName.length, cookieEnd));
    }
    return cookieValue;
}

//删除cookie
function unsetCookie(name) {
    document.cookie = name + "= ; expires=" + new Date(0);
}

20HTTP状态码

100  Continue  继续,一般在发送post请求时,已发送了http header之后服
务端将返回此信息,表示确认,之后发送具体参数信息
200  OK   正常返回信息
201  Created  请求成功并且服务器创建了新的资源
202  Accepted  服务器已接受请求,但尚未处理
301  Moved Permanently  请求的网页已永久移动到新位置。
302 Found  临时性重定向。
303 See Other  临时性重定向,且总是使用 GET 请求新的 URI。
304  Not Modified  自从上次请求后,请求的网页未修改过。

400 Bad Request  服务器无法理解请求的格式,客户端不应当尝试再次使
用相同的内容发起请求。
401 Unauthorized  请求未授权。
403 Forbidden  禁止访问。
404 Not Found  找不到如何与 URI 相匹配的资源。

500 Internal Server Error  最常见的服务器端错误。
503 Service Unavailable 服务器端暂时无法处理请求(可能是过载或维护)。

21js对象的深度克隆

function clone(Obj) {   
        var buf;   
        if (Obj instanceof Array) {   
            buf = [];  //创建一个空的数组 
            var i = Obj.length;   
            while (i--) {   
                buf[i] = clone(Obj[i]);   
            }   
            return buf;   
        }else if (Obj instanceof Object){   
            buf = {};  //创建一个空对象 
            for (var k in Obj) {  //为这个对象添加新的属性 
                buf[k] = clone(Obj[k]);   
            }   
            return buf;   
        }else{   
            return Obj;   
        }   
    }  

22、如何解决跨域问题?

jsonp、 
document.domain+iframe、
window.name、
window.postMessage、
服务器上设置代理页面

jsonp的原理是动态插入script标签

23、javascript对象的几种创建方式

1,工厂模式
2,构造函数模式
3,原型模式
4,混合构造函数和原型模式
5,动态原型模式
6,寄生构造函数模式
7,稳妥构造函数模式

24、一次完整的HTTP事务是怎样的一个过程?

基本流程:

a. 域名解析

b. 发起TCP的3次握手

c. 建立TCP连接后发起http请求

d. 服务器端响应http请求,浏览器得到html代码

e. 浏览器解析html代码,并请求html代码中的资源

f. 浏览器对页面进行渲染呈现给用户

25、对前端工程师这个职位你是怎么样理解的?

a. 前端是最贴近用户的程序员,前端的能力就是能让产品从 90分进化到 100 分,甚至更好

b. 参与项目,快速高质量完成实现效果图,精确到1px;

c. 与团队成员,UI设计,产品经理的沟通;

d. 做好的页面结构,页面重构和用户体验;

e. 处理hack,兼容、写出优美的代码格式;

f. 针对服务器的优化、拥抱最新前端技术

对于angular,react以及构建工具的内容以后详细讲解

请关照微信公众号:交互设计前端开发,...

本文分享自微信公众号 - 交互设计前端开发与后端程序设计(interaction_Designer),作者:json

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2017-04-22

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 如何写出好的 JavaScript —— 浅谈 API 设计

    很多同学觉得写 JavaScript 很简单,只要能写出功能来,效果能实现就好。还有一些培训机构,专门教人写各种“炫酷特效”,以此让许多人觉得这些培训很“牛逼”...

    前朝楚水
  • JavaScript 10分钟入门

    简介 JavaScript是一门面向对象的动态语言,他一般用来处理以下任务: 1、修饰网页 生成HTML和CSS 生成动态HTML内容 生成一些特效 2、提供...

    前朝楚水
  • 一些好用的jquery技巧

    1、返回顶部按钮 通过使用jQuery中的animate 和scrollTop 方法,不用插件就可以创建一个滚动到顶部的简单动画: // Back to to...

    前朝楚水
  • 借助FreeHttp为任意移动端web网页添加vConsole调试

    以下介绍在不用修改代码并发布项目的情况下,为我们日常使用的移动web应用(如手机web淘宝)添加vConsole调试工具的方法

    lulianqi
  • 第201天:js---实现继承的5种方式

    半指温柔乐
  • this_原型链_继承

    小胖
  • this,call,apply,bind(万字长文)

    大家好啊,我是吒儿?,每天努力一点点?,就能升职加薪?当上总经理出任CEO迎娶白富美走上人生巅峰?,想想还有点小激动呢?。

    达达前端
  • 前端AES的加密和解密

    在工作的过程中,经常要对一些数据做一些加密,当然有复杂的加密和简单的加密,也有对称加密等等。总之加密的方式有很多。今天在这里,我只是简单的分享一个我最近遇到的加...

    用户1174387
  • JavaScript中常见的十五种设计模式

    在JavaScript中并没有类这种概念,JS中的函数属于一等对象,在JS中定义一个对象非常简单(var obj = {}),而基于JS中闭包与弱类型等特性,在...

    书童小二
  • Javascript快速入门(上篇)

    Javascript的熟练之路,小弟来了。 ? JavaScript简介:JavaScript一种直译式脚本语言,是一种动态类型、弱类型、基于原型的语言,...

    用户1216676

扫码关注云+社区

领取腾讯云代金券