javascript OOP（下）（九）

<script>
function Person() {
var args = arguments;
if (typeof args[0] === 'object' && args[0]) { //判断第一个参数是否为对象，进行相应操作。传参为空时typeof null也是object，所以要同时判断args[0]不为空
if (args[0].name) {
this.name = args[0].name;
}
if (args[0].age) {
this.age = args[0].age;
} } else {
if (args[0]) {
this.name = args[0];
}
if (args[1]) {
this.age = args[1];
}
}
}
//toString继承自Object,一般的对象toString会显示"[object Object]"，没有什么意义，所以可以重新一下，方便输出
Person.prototype.toString = function() {
return 'name=' + this.name + ',age=' + this.age;
}var bosn = new Person('Bosn', 27);
bosn.toString(); //name=Bosn,age=27var lxy = new Person({
name: 'lxy',
age: 25
});
lxy.toString(); //name=lxy,age=25
</script>

<script>
function Person(name){
this.name=name;
}
function Student(name,className){
this.className=className;
Person.call(this,name); //调用基类的构造器
}var bosn=new Student('Bosn','Network064');
console.log(bosn);
</script>

<script>
Person.prototype.init=function(){};Student.prototype.init=function(){
//do sth
Person.prototype.init.apply(this,arguments);
}
</script>

<script>
function ClassManager(){//构造器
}ClassManager.prototype.addClass=function(str){ //在构造器上挂载一个方法，表示addClass
console.log('Class:'+str+' added.');
return this;// this总是指向ClassManager的实例，所以return就实现了链式调用
}var manager=new ClassManager();
manager.addClass('classA').addClass('classB').addClass('classC');
//Class:classA added.
//Class:classB added.
//Class:classC added.</script>

<script>
function DetectorBase(){
throw new Error('Abstract class can not be invoked directly!');
//在构造器里抛一个异常，防止抽象类被直接调用
}
DetectorBase.detect=function(){console.log('Detection starting...');}
DetectorBase.stop=function(){console.log('Detector stopped.');}
DetectorBase.init=function(){
throw new Error('Error');
//想要子类覆盖而不想被直接调用的方法，抛出异常
}function LinkDetector(){}
//通过Object.create实现继承
LinkDetector.prototype=Object.create(DetectorBase.prototype);
LinkDetector.prototype.constructor=LinkDetector;
</script>

<script>
//ES5里面对于属性有一些getter setter方法，有一些标签
//configurable:能否delete
//enumberable:能否for in遍历
//writable:能否读写属性
//value:记录属性值，默认为undefine
//控制属性的访问情况function Person(name){
//name可遍历，不可读写，不可删除
Object.defineProperty(this,'name',{value:name,enumerable:true});
}
//ARMS_NUM相当于定义了一个常量，可枚举，不可写，不可删除
Object.defineProperty(Person,'ARMS_NUM',{value:2,enumerable:true});
Object.seal(Person.prototype); //Person在初始化之后不想被扩展，不想被配置了，用seal方法
Object.seal(Person);function Student(name,className){
this.className=className;
Person.call(this,name);
}
Student.prototype=Object.create(Person.prototype);
Student.prototype.constructor=Student;
</script>

<script>
var moduleA;//只需要把最核心的东西moduleA放到全局作用域
moduleA=function(){
var prop=1;
function func(){}
return{ //func和prop不会被泄露到全局作用域
func:func,
prop:prop
}
}() //moduleA用立即执行的匿名函数
</script>

<script>
//通过new默认返回this的方法
va moduleA;
moduleA=new function(){
var prop=1;
function func(){}
this.func=func;
this.prop=prop;
}
</script>

<script>
var serial_maker=function(){
/*返回一个用来产生唯一字符串的对象。
唯一字符串由两部分组成：前缀+序列号。
该对象包含一个设置前缀的方法，一个设置序列号的方法和一个产生唯一字符串的gensym方法。
*/
var prefix='';
var seq=0;
return{
set_prefix:function(p){
prefix=String(p);
},
set_seq:function(s){
seq=s;
},
gensym:function(){
var result=prefix+seq;
seq+=1;
return result;
}
}
};
var seqer=serial_maker();
seqer.set_prefix('Q');
seqer.set_seq(1000);
var unique;
unique=seqer.gensym();
console.log(unique);//unique是"Q1000"
unique=seqer.gensym();
console.log(unique);//unique是"Q1001"</script>

seqer.gensym=function(){
var result=prefix+seq;
seq+=3;
console.log(seq);
return result;
}