基础总结（一）
1. JS取消默认事件和阻止事件冒泡
=====================原生js====================
1.阻止a标签的跳转和input的上传 //阻止浏览器的默认行为 function stopDefault( e ) { //阻止默认浏览器动作(W3C) if ( e && e.preventDefault ) e.preventDefault(); //IE中阻止函数器默认动作的方式 else window.event.returnValue = false; return false; } 2.阻止事件冒泡 function stopBubble(e) { //如果提供了事件对象，则这是一个非IE浏览器 if ( e && e.stopPropagation ) //因此它支持W3C的stopPropagation()方法 e.stopPropagation(); else //否则，我们需要使用IE的方式来取消事件冒泡 window.event.cancelBubble = true; }
=====================jQuery====================
3.如果使用jQuery，既可以阻止默认事件，也可以阻止冒泡
$('#linkA').on('click', function () {
return false
})
2. 强制类型和隐式类型转换
一、强制类型转换
Number()
parseInt()
parseFloat()
toString()
String()
Boolean()
注：
1.Number()
（1）如果是布尔值，true和false分别被转换为1和0
（2）如果是数字值，返回本身。
（3）如果是null，返回0.
（4）如果是undefined，返回NaN。
（5）如果是字符串，遵循以下规则：
1、如果字符串中只包含数字，则将其转换为十进制（忽略前导0）
2、如果字符串中包含有效的浮点格式，将其转换为浮点数值（忽略前导0）
3、如果是空字符串，将其转换为0
4、如果字符串中包含非以上格式，则将其转换为NaN
（6）如果是对象，则调用对象的valueOf()方法，然后依据前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()方法，再次依照前面的规则转换返回的字符串值。
2.parseInt()
（1）忽略字符串前面的空格，直至找到第一个非空字符
（2）如果第一个字符不是数字符号或者负号，返回NaN
（3）如果第一个字符是数字，则继续解析直至字符串解析完毕或者遇到一个非数字符号为止
（4）如果上步解析的结果以0开头，则将其当作八进制来解析；如果以0x开头，则将其当作十六进制来解析
（5）如果指定radix参数，则以radix为基数进行解析
3.parseFloat() 与parseInt基本相同 除了小数点
4.toString（）除了undefined和null都有toString的方法
5.Boolean(mix)函数，将任何类型的值转换为布尔值。
以下值会被转换为false：false、”"、0、NaN、null、undefined，其余任何值都会被转换为true
二、隐式类型转化
1) 字符串连接符+，会把其它数据类型转化为String()，然后字符串拼接
算数运算符+ 会把 数据类型转化为Number() 然后做+法运算
1+"true" = String(1) + "true" = "1true"
1+true = 1+Number(true) = 1+ 1 = 2
1+undefined = 1+Number(undefined) = 1+NaN = NaN
1+null = 1+Number(null) = 1+0 = 1
[]==![] => []==false => []==Number(false) => [] == 0 => [].toString() => 0 => '' == 0 => Number('') == 0 => 0 == 0
2）关系运算符两边如果有一边是字符串的话，会将其它数据类型转化为Number，进行比较
"2">10 => false //Number('2') > 10 => 2> 10 ==> false
3)关系运算符如果两边都是字符串的时候，同时转化为Number比较，而是把对应的Unicode编码转化为数字
"2" > "10" => true //
4) undefined == undefind => true
null == null => true
undefined == null => true
5)NaN和任何数据比较都是NaN
NaN == NaN => false
3. 创建对象的几种方式
1.字面式创建对象 //字面量创建对象，代码简单，缺点是会产生重复代码 var person = { name: 'Anglue', age: 15, getName: function () { return this.name } } console.log(person.getName()) 2.工厂模式 //工厂模式 instanceof 无法判断对象是谁的实例 function Stu(name){ let obj = new Object() obj.name = name return obj } let stu = new Stu('wahaha') console.log(stu.name) //'wahaha' console.log(stu instanceof Stu) //false console.log(stu instanceof Object) //true 3. 构造函数模式 function Stu(name,age){ this.name = name this.age = age this.getName = function () { return this.name } } var stu = new Stu('Xiaoming', 15) console.log(stu.getName()) console.log(stu instanceof Stu) //true 4.原型方法 //原型方式创建：优点是所有的实例都可以共享它的方法和属性，实例也可以定义自己的属性和方法，可以覆盖原型对象上的方法和属性名 function Stu(){ } Stu.prototype.name = 'Helan' Stu.prototype.getName = function(){ return this.name } var stu = new Stu() console.log(stu.getName()) //'Helan' var stu1 = new Stu() stu1.name = 'fuck' console.log(stu1.getName()) //'fuck' 5.组合式（构造函数+原型方法）常用 function Stu(name, age){ this.name = name this.age = age } Stu.prototype.getName = function(){ return this.name } Stu.prototype.getAge = function(){ return this.age } var stu = new Stu('Hong',22) console.log(stu.getName()) //'Helan' console.log(stu.getAge()) // 22
4. js中关于函数名和变量名重名，预解析，作用域的问题
1.js的预解析指的是变量的声明和函数的声明前置，函数的前置要比变量的声明前置提前， 举例：
function a(){}
var a = 1
console.log(a)
----------------------------------------------
var a = 1
function a(){}
console.log(a)
----------------------------------------------
以上两种形式都可以解析为一下结果
function a(){} //函数的声明优先前置
var a; //变量的声明前置
a = 1 //变量的赋值 number
console.log(a) //打印a 1
2.作用域：js在执行到某一个变量的时候，会先在本作用域查找变量，如果没有找到会到上一层作用域查找，以此类推
举例：
var a = 1;
function b(){
a = 10;
return;
function a(){
console.log(a);
}
}
b();
console.log(a);
首先分析预解析结果：
function b(){
function a(){
console.log(a);
}
a = 10
return
}
var a;
a = 1
b()
console.log(a)
在函数b中，先有一个函数名为a 的函数， 下面的 a = 10 赋值，此时在b()执行的时候，并没有调用a，所以a函数不执行，接下来a赋值为10，
首先查找变量a的地址，按照作用域链的查找方法，发现本作用于的b函数里面定义了一个变量名为a的函数，所以不需要继续向外查找，此时a=10就
赋值给了这个函数对象，外面的a不受影响
5.使用var声明和不使用var声明的变量
console.log(bin) var bin = 10 //output: undefined ------------------------------------------------------ console.log(bin) bin = 10 //output: Error: bin is not defined ------------------------------------------------------ function func(){ var bin = 10 console.log(bin) } func() // 10 console.log(bin) // error bin is not defuned ------------------------------------------------------ function func(){ bin = 10 console.log(bin) } func() // 10 console.log(bin) // 10 ------------------------------------------------------ var bin1 = 100; bin2 = 200 this.bin3 = 300 console.log(bin1) // 100 console.log(bin2) // 200 console.log(bin3) // 300 console.log(this.bin3) // 300 console.log(window.bin1) // 100 console.log(window.bin2) // 200 console.log(window.bin3) // 300 总结： 1.var声明的变量是在本作用域有效，不用var声明的变量属于全局window的一个属性； 2.var定义的变量不能使用delete， 不适用var定义的变量可以使用delete删除 3.var声明的变量会前置，属性不存在前置现象所以报错 4.为什么使用var bin1声明的也可以用window的属性来访问，因为声明bin1的作用域刚好是全局作用域，所以恰好可以使用window的属性来访问
6.JS原型和原型链
1. javascript 中分为普通对象和函数对象 凡是通过new Function 创建的对象都是函数对象,其余都是普通对象 js内置的函数对象：Date,String,Number,Object,Function,Boolean,Math... function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.getName = function () { return this.name } } var person1 = new Person('hollen', 20, 'teacher') var person2 = new Person('wile', 23, 'doctor') //person1和person2都是Person的实例，两个实例的contructor指针都指向构造函数Person console.log(person1.constructor === Person) //true console.log(person2.constructor === Person) //true 2.原型对象 js中每个函数都有prototype属性，这个属性指向函数的原型对象 【每个对象都有__proto__属性，但是只有函数有prototype属性】 为什么Person.prototype有一个contructor属性，因为原型对象Person.prototype 是构造函数Person的一个实例 在Person创建的时候，就创建了他的实例化对象并赋值给prototype 所以console.log(Person.prototype.contrutor === Person) //true function Person(){} Person.prototype.name = 'ZHENZHU' Person.prototype.age = 33 Person.prototype.job = 'teacher' Person.prototype.getName = function () { return this.name } console.log(Person.prototype.constructor === Person) //true
