js基础知识1

介绍JavaScript的基本数据类型。

ECMAScript中有5中简单数据类型(也称为基本数据类型): Undefined、Null、Boolean、Number和String。还有1中复杂的数据类型————Object,Object本质上是由一组无序的名值对组成的。

其中Undefined、Null、Boolean、Number都属于基本类型。Object、Array和Function则属于引用类型,String有些特殊,具体的会在下面展开分析。
string类型有些特殊,因为字符串具有可变的大小,所以显然它不能被直接存储在具有固定大小的变量中。由于效率的原因,我们希望JS只复制对字符串的引用,而不是字符串的内容。但是另一方面,字符串在许多方面都和基本类型的表现相似,而字符串是不可变的这一事实(即没法改变一个字符串值的内容),因此可以将字符串看成行为与基本类型相似的不可变引用类型

Boolean、Number、String 这三个是Javascript中的基本包装类型,也就是这三个其实是一个构造函数,他们是Function的实例,是引用类型,至于这里的String与以上说的String是同名,是因为其实上文说的String是指字符串,这里的String指的是String这个构造函数,上面那么写,是为了更好的理解,因为Javascript是松散类型的。我们可以看下String实例化的例子:

var name = String("jwy");
alert(typeof name);//"object"
var author = "Tom";
alert(typeof name);//"string"

说说写JavaScript的基本规范?

JavaScript原型,原型链?有什么特点?

原型:
每个对象都会在其内部初始化一个属性,就是prototype(原型)。

原型链:
当我们访问一个对象的属性时,如果这个对象内部不存在这个属性,那么他就会去prototype里找这个属性,这个prototype又会有自己的prototype,于是就这样一直找下去,也就是我们平时所说的原型链的概念。

特点:
JavaScript对象是通过引用来传递的,我们创建的每个新对象实体中并没有一份属于自己的原型副本。当我们修改原型时,与之相关的对象也会继承这一改变。
当我们需要一个属性的时,Javascript引擎会先看当前对象中是否有这个属性, 如果没有的话,就会查找他的Prototype对象是否有这个属性,如此递推下去,一直检索到 Object 内建对象

JavaScript有几种类型的值?(堆:原始数据类型和 栈:引用数据类型),你能画一下他们的内存图吗?

两大类:

栈:原始数据类型(Undefined,Null,Boolean,Number、String)

堆:引用数据类型(对象、数组和函数)

区别:

两种类型的区别是:存储位置不同;

原始数据类型直接存储在栈(stack)中的简单数据段,占据空间小、大小固定,属于被频繁使用数据,所以放入栈中存储;

引用数据类型存储在堆(heap)中的对象,占据空间大、大小不固定,如果存储在栈中,将会影响程序运行的性能;引用数据类型在栈中存储了指针,该指针指向堆中该实体的起始地址。当解释器寻找引用值时,会首先检索其

在栈中的地址,取得地址后从堆中获得实体

Javascript如何实现继承?

既然要实现继承,那么首先我们得有一个父类,代码如下:

// 定义一个动物类
function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉!');
  }
}
// 原型方法
Animal.prototype.eat = function(food) {
  console.log(this.name + '正在吃:' + food);
};

1、原型链继承

核心: 将父类的实例作为子类的原型

function Cat(){ 
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true

特点:
非常纯粹的继承关系,实例是子类的实例,也是父类的实例
父类新增原型方法/原型属性,子类都能访问到
简单,易于实现

缺点:
要想为子类新增属性和方法,必须要在new Animal()
这样的语句之后执行,不能放到构造器中
无法实现多继承
来自原型对象的引用属性是所有实例共享的
创建子类实例时,无法向父类构造函数传参

推荐指数:★★(3、4两大致命缺陷)

2、构造继承

核心:使用父类的构造函数来增强子类实例,等于是复制父类的实例属性给子类(没用到原型)

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

特点:
解决了1中,子类实例共享父类引用属性的问题
创建子类实例时,可以向父类传递参数
可以实现多继承(call多个父类对象)

缺点:
实例并不是父类的实例,只是子类的实例
只能继承父类的实例属性和方法,不能继承原型属性/方法
无法实现函数复用,每个子类都有父类实例函数的副本,影响性能

推荐指数:★★(缺点3)

3、实例继承

核心:为父类实例添加新特性,作为子类实例返回

function Cat(name){
  var instance = new Animal();
  instance.name = name || 'Tom';
  return instance;
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false

特点:
不限制调用方式,不管是new 子类()还是子类(),返回的对象具有相同的效果

缺点:
实例是父类的实例,不是子类的实例
不支持多继承

推荐指数:★★

4、拷贝继承

function Cat(name){
  var animal = new Animal();
  for(var p in animal){
    Cat.prototype[p] = animal[p];
  }
  Cat.prototype.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

特点:
支持多继承

缺点:
效率较低,内存占用高(因为要拷贝父类的属性)
无法获取父类不可枚举的方法(不可枚举方法,不能使用for in 访问到)

推荐指数:★(缺点1)
5、组合继承
核心:通过调用父类构造,继承父类的属性并保留传参的优点,然后通过将父类实例作为子类原型,实现函数复用

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
Cat.prototype = new Animal();

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true

特点:
弥补了方式2的缺陷,可以继承实例属性/方法,也可以继承原型属性/方法
既是子类的实例,也是父类的实例
不存在引用属性共享问题
可传参
函数可复用

缺点:
调用了两次父类构造函数,生成了两份实例(子类实例将子类原型上的那份屏蔽了)

推荐指数:★★★★(仅仅多消耗了一点内存)

6、寄生组合继承

核心:通过寄生方式,砍掉父类的实例属性,这样,在调用两次父类的构造的时候,就不会初始化两次实例方法/属性,避免的组合继承的缺点

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 创建一个没有实例方法的类
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //将实例作为子类的原型
  Cat.prototype = new Super();
})();

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true

特点:
堪称完美
缺点:
实现较为复杂

推荐指数:★★★★(实现复杂,扣掉一颗星)

function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉!');
  }
  //实例引用属性
  this.features = [];
}
function Cat(name){
}
Cat.prototype = new Animal();

var tom = new Cat('Tom');
var kissy = new Cat('Kissy');

console.log(tom.name); // "Animal"
console.log(kissy.name); // "Animal"
console.log(tom.features); // []
console.log(kissy.features); // []

tom.name = 'Tom-New Name';
tom.features.push('eat');

//针对父类实例值类型成员的更改,不影响
console.log(tom.name); // "Tom-New Name"
console.log(kissy.name); // "Animal"
//针对父类实例引用类型成员的更改,会通过影响其他子类实例
console.log(tom.features); // ['eat']
console.log(kissy.features); // ['eat']

原因分析:

关键点:属性查找过程

执行tom.features.push,首先找tom对象的实例属性(找不到),
那么去原型对象中找,也就是Animal的实例。发现有,那么就直接在这个对象的
features属性中插入值。
在console.log(kissy.features); 的时候。同上,kissy实例上没有,那么去原型上找。
刚好原型上有,就直接返回,但是注意,这个原型对象中features属性值已经变化了。

Javascript创建对象的几种方式?

  1. 使用Object构造函数来创建一个对象,下面代码创建了一个person对象,并用两种方式打印出了Name的属性值。
   var person = new Object();
   person.name="kevin";
   person.age=31;
   alert(person.name);
   alert(person["name"])
  1. 使用对象字面量创建一个对象;不要奇怪person["5"],这里是合法的;另外使用这种加括号的方式字段之间是可以有空格的如person["my age"].
    var person =  {
        name:"Kevin",
        age:31,
        5:"Test"
    };
    alert(person.name);
    alert(person["5"]);
  1. 使用工厂模式创建对象,返回带有属性和方法的person对象。
function createPerson(name, age,job) {
    var o = new Object();
    o.name=name;
    o.age=31;
    o.sayName=function() {
        alert(this.name);
    };
    return o;
}
createPerson("kevin",31,"se").sayName();
  1. 使用自定义构造函数模式创建对象;这里注意命名规范,作为构造函数的函数首字母要大写,以区别其它函数。这种方式有个缺陷是sayName这个方法,它的每个实例都是指向不同的函数实例,而不是同一个。
function Person(name,age,job) {
    this.name=name;
    this.age=age;
    this.job=job;
    this.sayName=function() {
      alert(this.name);
    };
}
var person = new Person("kevin",31,"SE");
person.sayName();
  1. 使用原型模式创建对象;解决了方法4中提到的缺陷,使不同的对象的函数(如sayFriends)指向了同一个函数。但它本身也有缺陷,就是实例共享了引用类型friends,从下面的代码执行结果可以看到,两个实例的friends的值是一样的,这可能不是我们所期望的。
 function Person(){
 }
 Person.prototype = {
    constructor : Person,
    name:"kevin",
    age:31,
    job:"SE",
    friends:["Jams","Martin"],
    sayFriends:function() {
        alert(this.friends);
    }
 };

 var person1 = new Person();
 person1.friends.push("Joe");
 person1.sayFriends();//Jams,Martin,Joe
 var person2 = new Person(); 
 person2.sayFriends();//James,Martin,Joe
  1. 组合使用原型模式和构造函数创建对象,解决了方法5中提到的缺陷,而且这也是使用最广泛、认同度最高的创建对象的方法。
function Person(name,age,job){
    this.name=name;
    this.age=age;
    this.job=job;
   this.friends=["Jams","Martin"];
}
Person.prototype.sayFriends=function(){
    alert(this.friends);
};
var person1 = new Person("kevin",31,"SE");
var person2 = new Person("Tom",30,"SE");
person1.friends.push("Joe");
person1.sayFriends();//Jams,Martin,Joe
person2.sayFriends();//Jams,Martin
  1. 动态原型模式;这个模式的好处在于看起来更像传统的面向对象编程,具有更好的封装性,因为在构造函数里完成了对原型创建。这也是一个推荐的创建对象的方法。
function Person(name,age,job) {
    //属性
    this.name=name;
    this.age=age;
    this.job=job;
    this.friends=["Jams","Martin"];
    //方法
    if(typeof this.sayName !="function") {
        Person.prototype.sayName=function() {
            alert(this.name);
        };
        Person.prototype.sayFriends=function() {
            alert(this.friends);
        };
    }
}
var person = new Person("kevin",31,"SE");
person.sayName();
person.sayFriends();

Javascript作用链域?

在JavaScript中,函数也是对象,实际上,JavaScript里一切都是对象。函数对象和其它对象一样,拥有可以通过代码访问的属性和一系列仅供JavaScript引擎访问的内部属性。其中一个内部属性是[[Scope]],由ECMA-262标准第三版定义,该内部属性包含了函数被创建的作用域中对象的集合,这个集合被称为函数的作用域链,它决定了哪些数据能被函数访问。

当一个函数创建后,它的作用域链会被创建此函数的作用域中可访问的数据对象填充。例如定义下面这样一个函数:

function add(num1,num2) {
    var sum = num1 + num2;
    return sum;
}

在函数add创建时,它的作用域链中会填入一个全局对象,该全局对象包含了所有全局变量,如下图所示(注意:图片只例举了全部变量中的一部分):

add创建时的作用域链

函数add的作用域将会在执行时用到。例如执行如下代码:
var total = add(5,10);
执行此函数时会创建一个称为“运行期上下文(execution context)”的内部对象,运行期上下文定义了函数执行时的环境。每个运行期上下文都有自己的作用域链,用于标识符解析,当运行期上下文被创建时,而它的作用域链初始化为当前运行函数的[[Scope]]所包含的对象。

这些值按照它们出现在函数中的顺序被复制到运行期上下文的作用域链中。它们共同组成了一个新的对象,叫“活动对象(activation object)”,该对象包含了函数的所有局部变量、命名参数、参数集合以及this,然后此对象会被推入作用域链的前端,当运行期上下文被销毁,活动对象也随之销毁。新的作用域链如下图所示:

total 创建时的作用域链

在函数执行过程中,没遇到一个变量,都会经历一次标识符解析过程以决定从哪里获取和存储数据。该过程从作用域链头部,也就是从活动对象开始搜索,查找同名的标识符,如果找到了就使用这个标识符对应的变量,如果没找到继续搜索作用域链中的下一个对象,如果搜索完所有对象都未找到,则认为该标识符未定义。函数执行过程中,每个标识符都要经历这样的搜索过程。

作用域链和代码优化
从作用域链的结构可以看出,在运行期上下文的作用域链中,标识符所在的位置越深,读写速度就会越慢。如上图所示,因为全局变量总是存在于运行期上下文作用域链的最末端,因此在标识符解析的时候,查找全局变量是最慢的。所以,在编写代码的时候应尽量少使用全局变量,尽可能使用局部变量。一个好的经验法则是:如果一个跨作用域的对象被引用了一次以上,则先把它存储到局部变量里再使用。例如下面的代码:

function changeColor(){
    document.getElementById("btnChange").onclick=function(){
        document.getElementById("targetCanvas").style.backgroundColor="red";
    };
}

这个函数引用了两次全局变量document,查找该变量必须遍历整个作用域链,直到最后在全局对象中才能找到。这段代码可以重写如下:

function changeColor(){
    var doc=document;
    doc.getElementById("btnChange").onclick=function(){
        doc.getElementById("targetCanvas").style.backgroundColor="red";
    };
}

这段代码比较简单,重写后不会显示出巨大的性能提升,但是如果程序中有大量的全局变量被从反复访问,那么重写后的代码性能会有显著改善。

js 的 with 语句如何深入理解?

with 语句用于设置代码在特定对象中的作用域。

var sMessage = "hello";
with(sMessage) {
  alert(toUpperCase()); //输出 "HELLO"
}

在这个例子中,with 语句用于字符串,所以在调用 toUpperCase() 方法时,解释程序将检查该方法是否是本地函数。如果不是,它将检查伪对象 sMessage,看它是否为该对象的方法。然后,alert 输出 "HELLO",因为解释程序找到了字符串 "hello" 的 toUpperCase() 方法。

提示:with 语句是运行缓慢的代码块,尤其是在已设置了属性值时。大多数情况下,如果可能,最好避免使用它。

var a = 123;
var b = {a : 321};
with(b){
    console.log(a); // 321
}

var a = 123;
var b = {}; //这里去掉b中的a属性
with(b){
    console.log(a); // 123
}

with语句中把对象b里面的属性的优先级高于该with所在作用域中其他同名变量。

谈谈This对象的理解。

简单来说 谁调用的方法this就是指向谁
1.函数调用(指向window) 简单不举例了
2.作为构造函数调用 ,指向使用new 产生的新对象
3.作为对象的方法调用

        function test(){
            alert(this.x);
        }
        var o = {};
        o.x=1;
        o.m=test;
        o.m();  //1
        //o.m=test();  //undefined

4.作为元素的节点
<input id="email" type="text" />

        var value = 'nihao';
        function f1(){
            alert(this.value);
        }
        var val = document.getElementById('email');
        val.onclick=f1;

在点击input之后我们会看到弹出的是我们输入的值,而不是window对象的’nihao’,这是 因为每一个获取的DOM元素也是一个对象;
5.call()和apply()
这两个函数的作用是相同的语法有一点不同;
他的作用是改变函数的调用对象,他的第一个参数就表示改变后的调用这个函数的对象(就是改变使用这个函数对象的this指向)
看下面的代码:

var name="helios";
    function setName(addr,weight){
        console.log(this.name+'---'+addr+'---'+weight);
        console.log('wancheng');
    }
    var cat = {name:'hei',age:12},
        dog = {name:'gou'};
    setName.call(dog,'shangsha',32);
    setName.apply(cat,['beijing',21]);

非预期效果

    var obj={
        bar:"yuansu",
        foo:function(){
            (function(){
                alert(this.bar);//这个this指向的window对象 会弹出undefined;
            })()
        }
    }
    obj.foo();

这里先要指出一个误区,不是在函数里面定义的函数,this就是指向的上一级函数的this这是不正确的,在函数里面定义的函数也是要看是谁调用的这个函数(方法)this才是谁;在这里并不是obj调用foo里面的匿名函数,实际上是window,如果想要达到预期的效果值许改一点代码就可以了,看下面代码:

    var obj={
        bar:"yuansu",
        foo:function(){
            var self = this;  //把obj这个对象用self保存下来
            (function(){
                alert(self.bar);//这里的self就是obj了
            })()
        }
    }
    obj.foo();

总结

调用形式 this指向
普通函数 window
构造函数 实例化后的对象
对象的方法 该对象
DOM节点 该节点对象
call或者apply 第一个参数

eval是做什么的?

把字符串参数解析成JS代码并运行,并返回执行的结果;
eval的作用域

functiona(){  
 eval("var x=1"); //等效于 var x=1;  
 console.log(x); //输出1  
}  
a();  
console.log(x);//错误 x没有定义  

说明作用域在它所有的范围内容有效

functiona(){  
 window.eval("var x=1"); // 等效于window.x=1;定义了全局变量  
 console.log(x); //输出1  
}  
a();  
console.log(x);//输出1  

什么是window对象?什么是document对象?

Window -- 代表浏览器中一个打开的窗口:
对象属性  
window //窗口自身  
window.self //引用本窗户window=window.self  
window.name //为窗口命名  
window.defaultStatus //设定窗户状态栏信息  
window.location //URL地址,配备布置这个属性可以打开新的页面
对象方法  
window.alert("text") //提示信息会话框  
window.confirm("text") //确认会话框  
window.prompt("text") //要求键盘输入会话框
window.setIntervel("action",time) //每一隔指定的时间(毫秒)就执行一次操作  
window.clearInterval() //清除时间配备布置作用就是终止轮回  window.setTimeout(action,time) //隔了指定的时间(毫秒)执行一次操作  window.open() //打开新的窗口  
window.close() //关闭窗口
成员对象  
window.event  
window.document //见document对象详解  
window.history  
window.screen  
window.navigator  
window.external  
-------------------------------------------------- -------------------  
window.history对象  
window.history.length //浏览过的页面数  
history.back() //后退  
history.forward() //前进  
history.Go(i) //前进或后退到历史记录的第i个页面  //i>0进步,i<0 后退 
------------------------------------------------- -------------------  
window.screen对象  
window.screen.width //屏幕宽度  
window.screen.height //屏幕高度  
window.screen.colorDepth //屏幕色深  
window.screen.availWidth //可用宽度  
window.screen.availHeight //可用高度(除去任务栏的高度)  
-------------------------------------------------- -------------------  
window.external对象  
window.external.AddFavorite("地址","标题" ) //把网站新增到保藏夹  
-------------------------------------------------- -------------------  window.navigator对象  
window.navigator.appCodeName //浏览器代码名  
window.navigator.appName //浏览器应用程序名  
window.navigator.appMinorVersion //浏览器补丁版本  window.navigator.cpuClass //cpu类型 x86  
window.navigator.platform //操作体系类型 win32  
window.navigator.plugins  
window.navigator.opsProfile  
window.navigator.userProfile  
window.navigator.systemLanguage //客户体系语言 zh-cn简体中文  
window.navigator.userLanguage //用户语言,同上  
window.navigator.appVersion //浏览器版本  
window.navigator.userAgent  
window.navigator.onLine //用户否在线  
window.navigator.cookieEnabled //浏览器是否撑持cookie  window.navigator.mimeTypes

document对象 -- 代表整个HTML 文档,可用来访问页面中的所有元素:
对象属性
document.title //设置文档标题等价于HTML的<title>标签
document.bgColor //设置页面背景色
document.fgColor //设置前景色(文本颜色)
document.linkColor //未点击过的链接颜色
document.alinkColor //激活链接(焦点在此链接上)的颜色
document.vlinkColor //已点击过的链接颜色
document.URL //设置URL属性从而在同一窗口打开另一网页
document.fileCreatedDate //文件建立日期,只读属性
document.fileModifiedDate //文件修改日期,只读属性
document.fileSize //文件大小,只读属性
document.cookie //设置和读出cookiedocument.charset
//设置字符集 简体中文:gb2312

常用对象方法
document.write() //动态向页面写入内容
document.createElement(Tag) //创建一个html标签对象
document.getElementById(ID) //获得指定ID值的对象
document.getElementsByName(Name) //获得指定Name值的对象
document.body.appendChild(oTag)

body-主体子对象
document.body //指定文档主体的开始和结束等价于<body></body>
document.body.bgColor //设置或获取对象后面的背景颜色document.body.link //未点击过的链接颜色
document.body.alink //激活链接(焦点在此链接上)的颜色
document.body.vlink //已点击过的链接颜色document.body.text //文本色
document.body.innerText //设置<body>...</body>之间的文本
document.body.innerHTML //设置<body>...</body>之间的HTML代码
document.body.topMargin //页面上边距
document.body.leftMargin //页面左边距
document.body.rightMargin //页面右边距
document.body.bottomMargin //页面下边距
document.body.background //背景图片
document.body.appendChild(oTag) //动态生成一个HTML对象

常用对象事件
document.body.onclick="func()" //鼠标指针单击对象是触发document.body.onmouseover="func()" //鼠标指针移到对象时触发document.body.onmouseout="func()" //鼠标指针移出对象时触发

selection-选区子对象
document.selection

location-位置子对象
document.location.hash // #号后的部分
document.location.host // 域名+端口号
document.location.hostname // 域名
document.location.href // 完整URL
document.location.pathname // 目录部分
document.location.port // 端口号
document.location.protocol // 网络协议
(http:)document.location.search // ?号后的部分

常用对象事件
documeny.location.reload() //刷新网页
document.location.reload(URL) //打开新的网页
document.location.assign(URL) //打开新的网页
document.location.replace(URL) //打开新的网页

images集合(页面中的图象):
a)通过集合引用
document.images //对应页面上的img标签
document.images.length //对应页面上img标签的个数
document.images[0] //第1个img标签
document.images[i] //第i-1个img标签
b)通过nane属性直接引用
<img name="oImage">
document.images.oImage //document.images.name属性
c)引用图片的src属性
document.images.oImage.src //document.images.name属性.src

null,undefined的区别?

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

(1) 作为函数的参数,表示该函数的参数不是对象。
(2) 作为对象原型链的终点。

Object.getPrototypeOf(Object.prototype)// null

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

(1)变量被声明了,但没有赋值时,就等于undefined。
(2)调用函数时,应该提供的参数没有提供,该参数等于undefined。
(3)对象没有赋值的属性,该属性的值为undefined。
(4)函数没有返回值时,默认返回undefined。

var i;
i // undefined

function f(x){console.log(x)}
f() // undefined

var  o = new Object();
o.p // undefined

var x = f();
x // undefined
Number(undefined) // NaN

Number(null) // 0

[“1”, “2”,“3”].map(parseInt)答案是多少?

结果是 [1, NaN, NaN]
parseInt(string, radix) //传2个参数
map传递的是 item, index, array
parseInt('2', 1) = NaN
parseInt('3', 2) = NaN

关于事件,IE与火狐的事件机制有什么区别? 如何阻止冒泡?

事件机制
事件冒泡:事件从当前元素对象触发,然后向上层元素搜索相同对象事件并触发(直搜到document节点)。IE事件默认都只这种类型的事件。
事件捕获:从document节点开始搜索事件,然后向下层搜索相同对象事件并触发,直到当前元素节点
阻止事件冒泡的方法
ie支持事件冒泡
火狐支持 捕获和冒泡两种
阻止冒泡
w3c支持 e.stopPropagation(),IE则是使用e.cancelBubble = true

什么是闭包(closure),为什么要用它?

1.函数内再嵌套函数
2.内部函数可以引用外层的参数和变量
3.参数和变量不会被垃圾回收机制回收

使用闭包的注意点
1)由于闭包会使得函数中的变量都被保存在内存中,内存消耗很大,所以不能滥用闭包,否则会造成网页的性能问题,在IE中可能导致内存泄露。解决方法是,在退出函数之前,将不使用的局部变量全部删除。
2)闭包会在父函数外部,改变父函数内部变量的值。所以,如果你把父函数当作对象(object)使用,把闭包当作它的公用方法(Public Method),把内部变量当作它的私有属性(private value),这时一定要小心,不要随便改变父函数内部变量的值。

javascript代码中的”use strict”;是什么意思?使用它区别是什么?

除了正常运行模式,ECMAscript 5添加了第二种运行模式:"严格模式"(strict mode)。顾名思义,这种模式使得Javascript在更严格的条件下运行。

  • 消除Javascript语法的一些不合理、不严谨之处,减少一些怪异行为;
  • 消除代码运行的一些不安全之处,保证代码运行的安全;
  • 提高编译器效率,增加运行速度;
  • 为未来新版本的Javascript做好铺垫。

"严格模式"体现了Javascript更合理、更安全、更严谨的发展方向,包括IE 10在内的主流浏览器,都已经支持它,许多大项目已经开始全面拥抱它。

  1. 全局变量显式声明
  "use strict";
  v = 1; // 报错,v未声明
  for(i = 0; i < 2; i++) { // 报错,i未声明
  }
  1. 禁止this关键字指向全局对象
      function f(){
        return !this;
      } 
      // 返回false,因为"this"指向全局对象,"!this"就是false
      function f(){ 
        "use strict";
        return !this;
      } 
      // 返回true,因为严格模式下,this的值为undefined,所以"!this"为true。

因此,使用构造函数时,如果忘了加new,this不再指向全局对象,而是报错。

    function f(){
    "use strict";
    this.a = 1;
  };
  f();// 报错,this未定义
  1. 禁止删除变量
    严格模式下无法删除变量。只有configurable设置为true的对象属性,才能被删除。
"use strict";
  var x;
  delete x; // 语法错误
  var o = Object.create(null, {'x': {
      value: 1,
      configurable: true
  }});
  delete o.x; // 删除成功
  1. 对象不能有重名的属性
    正常模式下,如果对象有多个重名属性,最后赋值的那个属性会覆盖前面的值。严格模式下,这属于语法错误。
"use strict";
  var o = {
    p: 1,
    p: 2
  }; // 语法错误
  1. 函数不能有重名的参数
    正常模式下,如果函数有多个重名的参数,可以用arguments[i]读取。严格模式下,这属于语法错误。
 "use strict";
  function f(a, a, b) { // 语法错误
    return ;
  }

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

instanceof 运算符:instanceof 运算符要求其左边的运算数是一个对象,右边的运算数是对象类的名字或构造函数。如果 object 是 class 或构造函数的实例,则 instanceof 运算符返回 true。如果 object 不是指定类或函数的实例,或者 object 为 null,则返回 false。

new操作符具体干了什么呢?

new操作符具体干了什么呢?其实很简单,就干了三件事情。

var obj = new Base();  

var obj  = {}; 
obj.__proto__ = Base.prototype; 
Base.call(obj);  

第一行,我们创建了一个空对象obj
第二行,我们将这个空对象的proto成员指向了Base函数对象prototype成员对象
第三行,我们将Base函数对象的this指针替换成obj,然后再调用Base函数,于是我们就给obj对象赋值了一个id成员变量,这个成员变量的值是”base”

Javascript中,有一个函数,执行时对象查找时,永远不会去查找原型,这个函数是?

hasOwnProperty
//
JavaScript 中 hasOwnProperty 函数方法是返回一个布尔值,指出一个对象是否具有指定名称的属性。此方法无法检查该对象的原型链中是否具有该属性;该属性必须是对象本身的一个成员。
//
使用方法:
object.hasOwnProperty(proName)
其中参数object是必选项,一个对象的实例。
proName是必选项,一个属性名称的字符串值。
//
如果 object 具有指定名称的属性,那么JavaScript中hasOwnProperty函数方法返回 true,反之则返回 false。

对JSON的了解?

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。
它是基于JavaScript的一个子集。数据格式简单,易于读写,占用带宽小。
如:
{"age":"12", "name":"back"}
JSON对象定义了两个方法:

stringify()   ,JS对象序列化为JSON字符串
parse()       ,JSON字符串解析为JS对象

为什么JavaScript不推荐使用其原生函数eval()解析json?

eval函数功能强大,常用于求值。但是,eval函数并不会对求值内容做检查,尤其是对字符串。因此,使用eval得到的并不是JSON,可能是一段恶意程序。

能解释一下这段代码的意思吗?

[].forEach.call($$("*"),function(a){
a.style.outline="1px solid #"+(~~(Math.random()*(1<<24))).toString(16)
 })

$$("")为选取全部的标签,nodeList 不存在foeEach方法
[].forEach.call()是一种快速的方法访问forEach,并将空数组的this换成$$("
")
(~~(Math.random()*(1<<24))).toString(16) 是产生一个随机6位的16进制数字
和 "1px solid #" 组合成样式代码
赋值给元素的outline属性。
即给所有元素添加随机颜色的轮廓

js延迟加载的方式有哪些?

1.defer 属性,该属性用来通知浏览器,这段脚本代码将不会产生任何文档内容。例如 JavaScript代码中的document.write()方法将不会骑作用,浏览器遇到这样的代码将会忽略,并继续执行后面的代码。属性只能是 defer,与属性名相同。在HTML语法格式下,也允许不定义属性值,仅仅使用属性名。加上 defer 等于在页面完全在入后再执行.

<scriptsrc="file.js" defer></script>

2.async 属性,不能保证脚本会按顺序执行。它们将在onload 事件之前完成。async和defer一样,都不会阻塞其他资源下载,所以不会影响页面的加载,但在async的情况下,js文档一旦下载完毕就会立刻执行,所以很有可能不是按照原本的顺序来执行

<scriptsrc="file.js" async></script>

3.动态创建DOM方式

<script type="text/javascript">  
   function downloadJSAtOnload() {  
       varelement = document.createElement("script");  
      element.src = "defer.js";  
      document.body.appendChild(element);  
   }  
   if (window.addEventListener)  
      window.addEventListener("load",downloadJSAtOnload, false);  
   else if (window.attachEvent)  
      window.attachEvent("onload",downloadJSAtOnload);  
   else window.onload =downloadJSAtOnload;  
</script>  

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

Asynchronous Javascript And XML。
异步传输+js+xml。
所谓异步,在这里简单地解释就是:向服务器发送请求的时候,我们不必等待结果,而是可以同时做其他的事情,等到有了结果它自己会根据设定进行后续操作,与此同时,页面是不会发生整页刷新的,提高了用户体验。

  1. 创建Ajax核心对象XMLHttpRequest
 var xmlhttp;  
if (window.XMLHttpRequest)  
  {// 兼容 IE7+, Firefox, Chrome, Opera, Safari  
  xmlhttp=new XMLHttpRequest();  
  }  
else  
  {// 兼容 IE6, IE5  
  xmlhttp=newActiveXObject("Microsoft.XMLHTTP");  
  } 
  1. 向服务器发送请求
    xmlhttp.open(method,url,async);  
    send(string)  

注意:open 的参数要牢记,很多面试官爱问这样的细节

- method:请求的类型;GET 或 POST
- url:文件在服务器上的位置
- async:true(异步)或 false(同步)

send(string)方法post请求时才使用字符串参数,否则不用带参数。
注意:post请求一定要设置请求头的格式内容

 xmlhttp.open("POST","ajax_test.html",true);  
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");  
xmlhttp.send("fname=Henry&lname=Ford"); 
  1. 服务器响应处理
    responseText 获得字符串形式的响应数据。
    responseXML 获得XML 形式的响应数据。

3.1 同步处理
直接在send()后面处理返回来的数据。

 xmlhttp.open("GET","ajax_info.txt",false);  
xmlhttp.send();  
document.getElementById("myDiv").innerHTML=xmlhttp.responseText; 

3.2 异步处理

异步处理相对比较麻烦,要在请求状态改变事件中处理。
 xmlhttp.onreadystatechange=function()  
  {  
  if (xmlhttp.readyState==4 &&xmlhttp.status==200)  
    {  
   document.getElementById("myDiv").innerHTML=xmlhttp.responseText;  
    }  
  } 
xmlhttp.readyState一共有5中请求状态,从0 到 4 发生变化。
0: 请求未初始化
1: 服务器连接已建立
2: 请求已接收
3: 请求处理中
4: 请求已完成,且响应已就绪
xmlhttp.status:响应状态码。这个也是面试比较爱问的,这个必须知道4个以上,比较常见的有:

200: "OK"
403   (禁止) 服务器拒绝请求。
404   (未找到) 服务器找不到请求的网页。
408  (请求超时) 服务器等候请求时发生超时。
500   (服务器内部错误)  服务器遇到错误,无法完成请求。

同步和异步的区别?

jquery中ajax方法有个属性async用于控制同步和异步,默认是true,即ajax请求默认是异步请求,有时项目中会用到AJAX同步。这个同步的意思是当JS代码加载到当前AJAX的时候会把页面里所有的代码停止加载,页面出现假死状态,当这个AJAX执行完毕后才会继续运行其他代码页面假死状态解除。而异步则这个AJAX代码运行中的时候其他代码一样可以运行。

ajax中async这个属性,用于控制请求数据的方式,默认是true,即默认以异步的方式请求数据。

如何解决跨域问题?

1、JSONP:
使用方式就不赘述了,但是要注意JSONP只支持GET请求,不支持POST请求。

2、代理:
例如www.123.com/index.html需要调用www.456.com/server.php,可以写一个接口www.123.com/server.php,由这个接口在后端去调用www.456.com/server.php并拿到返回值,然后再返回给index.html,这就是一个代理的模式。相当于绕过了浏览器端,自然就不存在跨域问题。

3、服务端设置
header('Access-Control-Allow-Origin:*');//允许所有来源访问
header('Access-Control-Allow-Method:POST,GET');//允许访问的方式

谈一谈你对ECMAScript6的了解?

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

class People{    
  constructor(name,age){//类似java的构造方法,不过只能有一个
        this.name = name
        this.age = age    
  }    
  get height1(){//类似java的属性的get方法
        console.log("get")
        return this.height
    }    
  set height1(newHeight){//类似java的属性的set方法
        console.log("set")
        this.height = newHeight
    }
}

继承

class Student extends People{
    constructor(name,age,weight){//还是只有一个构造方法        
        super(name,age)//必须调用父类的构造方法
        this.weight = weight
    }    
say(){
        super.say()//写与不写都会默认调用父类的,(测试过),和java的小差别
        return "方法重写:" + this.weight
    }}
let s = new Student("li","26","120")
console.log(s.say())

静态属性和方法

class Student extends People{
    static hangle(){
        console.log("静态方法")
    }}
Student.a = 10//静态属性
console.log(Student.a)//静态属性的使用
Student.hangle()//静态方法的调用

面向对象的语言有一个标志,那就是他们都有类的概念,通过类可以创建任意多个具有相同属性和方法的对象。
ECMAScript5中没有类的概念,因此它的对象和基于类的语言中的对象有所不同。
Javascript生成对象的传统方法是通过构造函数来实现的

documen.write和innerHTML的区别?

document.write 只能重绘整个页面
innerHTML 可以重绘页面的一部分

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.getElementByIdx("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); //浅复制

.call()和.apply()的含义和区别?

all函数和apply方法的第一个参数都是要传入给当前对象的对象,及函数内部的this。后面的参数都是传递给当前对象的参数。

对于apply和call两者在作用上是相同的,但两者在参数上有区别的。
对于第一个参数意义都一样,但对第二个参数:
apply传入的是一个参数数组,也就是将多个参数组合成为一个数组传入,而call则作为call的参数传入(从第二个参数开始)。
如 func.call(func1,var1,var2,var3)对应的apply写法为:func.apply(func1,[var1,var2,var3])

同时使用apply的好处是可以直接将当前函数的arguments对象作为apply的第二个参数传入

数组和对象有哪些原生方法,列举一下?

JavaScript中的作用域与变量声明提升?

如何编写高性能的Javascript?

那些操作会造成内存泄漏?

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

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

typeof window=="undefined"?global:window;

移动端最小触控区域是多大?

Apple的IPhone Human Interface Guidelines推荐触控目标的最小尺寸是4444 pixels。Google的Android Design说7-10mm是比较理想的尺寸。Microsoft的Windows Phone UI Design and Interaction Guide推荐的最小触控目标尺寸为77mm(2626px),理想的尺寸为99mm(3434px)。Nokia的开发指南建议目标尺寸应该不小于1010mm(28*28px)。

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

按照HTML5标准中的HTML语法规则,如果在</body>后再出现<script>或任何元素的开始标签,都是parse error,浏览器会忽略之前的</body>,即视作仍旧在body内。所以实际效果和写在</body>之前是没有区别的。总之,这种写法虽然也能work,但是并没有带来任何额外好处,实际上出现这样的写法很可能是误解了“将script放在页面最末端”的教条。所以还是不要这样写为好。

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

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

解释JavaScript中的作用域与变量声明提升?

那些操作会造成内存泄漏?

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

Node.js的适用场景?

(如果会用node)知道route,

middleware, cluster, nodemon, pm2, server-side rendering么?

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

什么是“前端路由”?什么时候适合使用“前端路由”?

“前端路由”有哪些优点和缺点?

知道什么是webkit么?知道怎么用浏览器的各种工具来调试和debug代码么?

如何测试前端代码么?知道BDD, TDD, Unit Test么?知道怎么测试你的前端工程么(mocha, sinon, jasmin, qUnit..)?

前端templating(Mustache,

underscore, handlebars)是干嘛的,怎么用?

简述一下Handlebars的基本用法?

简述一下Handlerbars的对模板的基本处理流程, 如何编译的?如何缓存的?

用js实现千位分隔符?(来源:前端农民工,提示:正则+replace)

检测浏览器版本版本有哪些方式?

我们给一个dom同时绑定两个点击事件,一个用捕获,一个用冒泡,你来说下会执行几次事件,然后会先执行冒泡还是捕获

推荐阅读更多精彩内容