1.获取对象 obj 的所有属性(自有属性和继承属性),保存到数组 lst 中
//获取对象obj的所有属性(自有属性和继承属性),保存到数组lst 中
var lst = [];
function getAllAttrs(obj){
var arr = Object.getOwnPropertyNames(obj);
for(r in arr){
lst.push(arr[r]);
}
if(obj.__proto__ !== null){
obj = obj.__proto__;
getAllAttrs(obj);
}
}
getAllAttrs(obj);
console.log(lst);
2.实现一个完整的复数类
//实现一个完整的复数类: Complex //定义构造函数
function Complex(real, imaginary){
if(isNaN(real) || isNaN(imaginary)) throw TypeError();
this.r = real;
this.i = imaginary;
};
// 定义非静态方法
Complex.prototype.add = function(that){
return new Complex(this.r+that.r,this.i+that.i);
};
Complex.prototype.mui = function(that){
return new Complex(this.r*that.r-this.i*that.i,this.r*that.r+this.i*that.i);
};
//取模运算
Complex.prototype.mag = function(){
return Math.sqrt(this.r*this.r+this.i*this.i);
};
Complex.prototype.neg = function(){
return new Complex(-this.r,-this.i);
};
Complex.prototype.toString = function(){
return "{"+this.r+", "+this.i+"}";
};
Complex.prototype.equals = function(that){
return that != null &&
that.constructor === Complex &&
this.r === that.r &&
this.i === that.i;
};
//定义类静态属性
Complex.ZERO = new Complex(,);
Complex.ONE = new Complex(,);
Complex.I = new Complex(,);
//定义类静态方法
Complex.parse = function(s){
try{
var m = Complex._format.exec(s);
return new Complex(parseFloat(m[]),parseFloat(m[]));
}catch(x){
throw new TypeError("Can't parse "+s+" as a complex number.");
}
};
//静态类属性
Complex._format = /^\{([^,]+),([^}]+)\}$/; //使用
var c = new Complex(,);
var d = new Complex(c.i,c.r);
console.log(c.add(d).toString()); // {5, 5}
console.log(Complex.parse(c.toString())); // Complex {r: 2, i: 3}
console.log(Complex.parse(c.toString()).add(c.neg()).equals(Complex.ZERO)); // true
3.判断鸭辩型
//判断鸭辩型
//如果 o 实现了除第一个参数之外的参数所表示的同名方法, 则返回true
function quacks3(o){
for(var i=;i<arguments.length;++i){//遍历o之后的所有参数
var arg = arguments[i];
switch(typeof arg){
case 'string': // 参数为string直接用名字检查
if(typeof o[arg] !== "function")
return false;
continue;
case 'function': // 参数为函数, 视为构造函数, 检查函数的原型对象上的方法
arg = arg.prototype; //进入下一个case
case 'object':
for(var m in arg){ //遍历对象的每个属性
if(typeof arg[m] !== 'function') //跳过不是方法的属性
continue;
if(typeof o[m] !== 'function')
return false;
} }
}
return true;
}
//说明: 只检测函数名,而不用管细节, 不是强制的API,因此满足鸭辩型的本质, 灵活
//限制: 不能用于内置类, 因为for/in不能遍历不可枚举的方法. 在ES5中可以使用Object.getOwnPropertyNames()
function quacks5(o){
for(var i=;i<arguments.length;++i){
var arg = arguments[i];
switch(typeof arg){
case 'string':
if(typeof o[arg] !== 'function')
return false;
continue;
case 'function':
arg = arg.prototype;
case 'object':
var props = Object.getOwnPropertyNames(arg.__proto__);
var props2 = Object.getOwnPropertyNames(arg);
for(var prop in props2){
props.push(props2[prop]);
}
for(var m in props){
if(props[m] !== 'function')
continue;
if(o[m] !== 'function')
return false;
}
}
}
return true;
};
4.合并多个对象属性
// 将变长参数sources对象的可枚举(for/in)属性合并到target中,并返回target
// target 的值是被修改的, 深拷贝(递归合并)
// 合并从左到右进行, 同名属性保持和左边一样(除非属性是空对象)
function myextend(target /*...sources*/){
if(!arguments.length)
return undefined;
if(arguments.length === )
return target;
for(var i=;i<arguments.length;++i){
var source = arguments[i];
for(var prop in source){
if(target.hasOwnProperty(prop) &&
target[prop] !== undefined &&
target[prop] != {}) // 目标对象上该属性存在且属性值不为undefined(可以为null)且不为空对象
continue;
if(typeof source[prop] === 'object'){
target[prop] = {};
target[prop] = myextend({},source[prop]);
}else{
target[prop] = source[prop];
}
}
}
return target;
}
测试:
// 结果在chrome console中查看
var target = {
t1:,
t2:{
t1:,
t2:{
t1:,
t2:"t2"
}
}
};
var source1 = {
s1:,
s2:{
s1:,
s2:{
s1:,
s2:"s2"
}
}
};
var source2 = {
r1:,
r2:{
r1:,
s2:{
r1:,
r2:"s2"
}
}
};
var t = myextend(target,source1,source2);
console.log(t);
5.为对象添加一个id属性
(function(){
Object.defineProperty(Object.prototype,"objectId",{
get: idGetter,
enumerable: false,
configurable: false
});
function idGetter(){
if(!(idprop in this)){
if(!Object.isExtensible(this))
throw Error("Can't define id for nonextensible objects");
Object.defineProperty(this,idprop,{
value: nextid++,
writable: false,
enumerable: false,
configurable: false
});
return this[idprop];
}
}
var idprop = "|***objectId*|";
var nextid = ;
})();
var obj = {};
console.log(obj.objectId); // 1
6.让函数既可以当成构造函数,也可以当成工厂方法调用
// 既可以当成构造函数用, 也可以当成工厂方法来用
function Range(from, to){
var props = {
from:{value:from,enumerable:true,writable:false,configurable:false},
to:{value:to,enumerable:true,writable:false,configurable:false}
};
if(this instanceof Range){ // 如果作为构造函数来调用的话
Object.defineProperties(this,props);
}else{ // 否则当成作为工厂方法来调用
return Object.create(Range.prototype,props);
}
}
持续更新中...
参考
1. <<JavaScript权威指南: 第6版>>
-->