第一篇
第一章 js基础知识,函数的编写方式
一：函数的声明 此类声明会创建全局变量checkName如果函数多 不建议使用 可能会被覆盖
-
function checkName(){}声明会提前 可以在函数定义前使用 -
var checkName = function(){}不能在函数定义前使用 定义一个匿名函数 赋值给checkName
二：用对象收编变量 {}表示定义一个对象 对象习惯首字母大写
2.1:创建对象，添加属性和方法 单例模式 所有的访问都是同一个对象
var CheckObj1 = {
checkName:function(){
//验证
},checkEmail:function(){
//验证
}}
//访问 CheckObj1.checkName()访问
不能new CheckObj1(),报a is not a constructor没有构造函数 有function才可以new
2.2：对象的另一种形式
var CheckObj2 = function(){
};
CheckObj2.checkName = function(){};
CheckObj2.checkEmail = function(){};
//访问 CheckObj2.checkName()访问
可以var a = new CheckObj2(),但是a.checkName()会报错 必须 CheckObj2.checkName()
也就是说new创建新对象的时候 新对象时不能继承这些方法的
2.3:真假对象 把方法放在一个函数中 调用时把返回一个新对象 在使用时互不影响
var CheckObj3 = function(){
return{
checkName:function(){},
checkEmail:function(){}
}
}
var a = CheckObj3();
//也可以var a = new CheckObj3(); new 返回指向CheckObj3的引用 也可以调用
a.checkName();
2.4:类对象
var CheckObj4 = function(){
this.checkName = function(){}
this.checkEmail = function(){}
}
类对象可以看成一个类
var a = new CheckObj4();
a.checkName(); 注意和2的区别 2是直接在类名上面添加属性和方法,实例化时并没有添加实例化的对象上面
实例化对象时 会把属性和方法都复制 新创建的对象都会有自己的一套方法,会造成一定的消耗
这样var a = CheckObj4();会把checkName和checkEmail加在window上去.this指向window.用new构建对象会生成并返回指向当前对象的this。为避免出现忘记new可以用安全模式
2.5 检测类(原型链prototype)
var CheckObj5 = function(){
}
CheckObj5.prototype = {
checkName:function(){},
checkEmail:function(){}
}
//使用
var checkObj5 = new CheckObj5();
checkObj5.checkName();
checkObj5.checkEmail();
//要想链式调用 需返回this
CheckObj5.prototype = {
checkName:function(){ //code return this},
checkEmail:function(){ //code return this}
}
就可以 checkObj5.checkName().checkEmail()；
2.6 用prototype.js 框架扩展
1: 直接在Function扩展
Function.prototype.checkEmail = function(){} //污染了原生Function对象
var f = function(){} f.checkEmail();
2：抽象一个统一添加的功能方法
Function.prototype.addMethod = (name,fn){
//不用new调用
this[name] = fn;
//用new类式调用
//this.prototype[name] = fn
return this; //链式调用
}
var methods = function(){};
methods.addMethod('checkName',function(){})
//new 调用
//var m = new methods; m.checkName()
methods.checkName();
第二章 js面向对象####
编程风格1:面向对象,把需求抽象为一个对象,对对象添加相关属性和方法,又称为类.特点是封装(把需要的功能放一个对象里面)2:面向过程
2.1 包装 --- 分类
2.1.1 创建类
类首字母大写
way1: 通过this创建
var Book = function(id,bookname){
//id 和 name属性每次new都会重新构建
this.id = id;
this.bookname = bookname;
}
way2: 通过prototype创建
Book.prototype = {
//ids display公用一个 且实例对象改变 新的实例对象不会变
//数组和对象是引用类型就会跟着一起改变
ids:'1002',
arr:[1,2,3],
display:function(){console.log(this.ids)}
}
var book = new Book("1001","演员的自我修养");
book.ids = 1006;
book.arr.push(9);
book.display(); //1006
book.arr //1,2,3,9
var book2 = new Book()
book2.display(); // 还是1002 不受book对象ids值改变的影响
book2.arr //也跟着变为 1,2,3,9
2.1.2 私有方法和属性
var Book = funcion(){
//私有属性和私有方法 方法的内部不是能this调用对象的公有方法、公有属性、特权方法的
//外部不能直接访问 可以通过特权方法访问
var num = 1;
var checkId = function(){};
//特权方法 返回私有的给外部使用
this.getName = function(){
return num;
};
this.getcheckId = function(){
return checkId;
}
//公有属性
this.id = id;
//公有方法 实例化时复制一套
this.copy = function(){};
//公有方法和属性 实例化时共用一套
Book.prototype = {
id:'1001',
display:function(){}
}
//构造器
this.setName(name)
}
//类静态公有属性 通过Book.type调用
Book.type = "country";
2.1.3 闭包实现-变量访问权限 控制实例化次数
var Book = (function(){
//静态私有变量
console.log("One")
var bookNum = 0;
//静态私有方法
function checkBook(){}
//返回构造函数
function _book(newId,newName,newPrice){
//私有变量
var name,price;
//私有方法
function checkId(id){};
//特权方法
this.getName = function(){}
//公有属性
this.id = newId;
//公有方法
this.copy = function(){};
bookNum++;
console.log(bookNum);
if(bookNum>3){
console.log("不能再加了")
}
//构造器
this.setName(name);
}
_book.prototype = {
//静态公有属性和方法
isJSBook :false,
display:funciton(){}
};
//返回类 构造函数里，如果返回一个非null的对象，
则将该对象值赋值给新建的对象，也就是说new Book返回的是_book.
return _book;
})();
new Book();
Book();
Book();
Book();
为什么One只输出一次 bookNum为什么一值能累加
()()在这里面闭包的作用是什么，不加()()为什么不行
解答 console.log("One")是在函数定义的时候就执行的
无论你是否有调用BooK都会输出One(自执行),
执行完后返回一个function(_book);每次Book()时都是调用_book();
bookNum在它作用域外已经声明,
已有一个地址保存，所以能累加,自执行也只能执行最外层function的代码
参考网址http://www.jb51.net/article/34821.htm http://it.techqing.com/thread-127698-1-1.html
惰性函数http://www.jianshu.com/p/9559ebdcc055