手机浏览 RSS 2.0 订阅 膘叔的简单人生 , 腾讯云RDS购买 | 超便宜的Vultr , 免费部署 N8N 的 Zeabur 注册 | 登陆
浏览模式: 标准 | 列表2025年11月的文章

累

Submitted by gouki on 2008, April 29, 11:25 PM

累啊……

Misc | 评论:0 | 阅读:21642

最近一直在转贴文章……

Submitted by gouki on 2008, April 28, 8:25 AM

最近自己写的东西少了，思想的沉淀是需要一个过程的。目前思想还没有空沉淀，所以……转贴占了多数，不过。这并不妨碍我的学习热情，之所以转贴，那是代表我需要学习，或者需要收藏它，不是吗？

当然，如果遇到什么未知的情况，我还是会第一时间写下来的。好记性不如烂笔头。虽然现在不再用笔记录，但用计算机来记录点滴也是可以让自己多一份回忆的。

Tags: 侃, 转贴

Misc | 评论:0 | 阅读:22566

面向对象编程五大原则［转］

Submitted by gouki on 2008, April 27, 11:25 PM

COPY自老狼网站,原文链接：http://laolang.xtmm.cn/post/209.htm
 
单一职责原则SRP：Single Responsibility Principle
开放封闭原则OCP：Open－Close Principle
Liskov替换原则LSP：Liskov Substitution Principle
依赖倒置原则DIP：Dependency Invertion Principle
接口隔离原则ISP：Interface Separate Principle

　　在面向对象设计中，如何通过很小的设计改变就可以应对设计需求的变化，这是令设计者极为关注的问题。为此不少OO先驱提出了很多有关面向对象的设计原则用于指导OO的设计和开发。下面是几条与类设计相关的设计原则。

1. 开闭原则（the Open Closed Principle OCP）
　　一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。因此在进行面向对象设计时要尽量考虑接口封装机制、抽象机制和多态技术。该原则同样适合于非面向对象设计的方法，是软件工程设计方法的重要原则之一。我们以收音机的例子为例，讲述面向对象的开闭原则。我们收听节目时需要打开收音机电源，对准电台频率和进行音量调节。但是对于不同的收音机，实现这三个步骤的细节往往有所不同。比如自动收缩电台的收音机和按钮式收缩在操作细节上并不相同。因此，我们不太可能针对每种不同类型的收音机通过一个收音机类来实现（通过重载）这些不同的操作方式。但是我们可以定义一个收音机接口，提供开机、关机、增加频率、降低频率、增加音量、降低音量六个抽象方法。不同的收音机继承并实现这六个抽象方法。这样新增收音机类型不会影响其它原有的收音机类型，收音机类型扩展极为方便。此外，已存在的收音机类型在修改其操作方法时也不会影响到其它类型的收音机。

2. 替换原则 (the Liskov Substitution Principle LSP)
　　子类应当可以替换父类并出现在父类能够出现的任何地方。这个原则是Liskov于1987年提出的设计原则。它同样可以从Bertrand Meyer 的DBC (Design by Contract) 的概念推出。
　　我们以学生为例，夜校生为学生的子类，因此在任何学生可以出现的地方，夜校生均可出现。这个例子有些牵强，一个能够反映这个原则的例子时圆和椭圆，圆是椭圆的一个特殊子类。因此任何出现椭圆的地方，圆均可以出现。但反过来就可能行不通。
　　运用替换原则时，我们尽量把类B设计为抽象类或者接口，让C类继承类B（接口B）并实现操作A和操作B，运行时，类C实例替换B，这样我们即可进行新类的扩展（继承类B或接口B），同时无须对类A进行修改。

3. 依赖原则 (the Dependency Inversion Principle DIP)
　　在进行业务设计时，与特定业务有关的依赖关系应该尽量依赖接口和抽象类，而不是依赖于具体类。具体类只负责相关业务的实现，修改具体类不影响与特定业务有关的依赖关系。
　　在结构化设计中，我们可以看到底层的模块是对高层抽象模块的实现（高层抽象模块通过调用底层模块），这说明，抽象的模块要依赖具体实现相关的模块，底层模块的具体实现发生变动时将会严重影响高层抽象的模块，显然这是结构化方法的一个"硬伤"。
　　面向对象方法的依赖关系刚好相反，具体实现类依赖于抽象类和接口。
　　为此，我们在进行业务设计时，应尽量在接口或抽象类中定义业务方法的原型，并通过具体的实现类（子类）来实现该业务方法，业务方法内容的修改将不会影响到运行时业务方法的调用。

4. 接口分离原则（the Interface Segregation Principle ISP）
采用多个与特定客户类有关的接口比采用一个通用的涵盖多个业务方法的接口要好。
　　ISP原则是另外一个支持诸如COM等组件化的使能技术。缺少ISP，组件、类的可用性和移植性将大打折扣。
　　这个原则的本质相当简单。如果你拥有一个针对多个客户的类，为每一个客户创建特定业务接口，然后使该客户类继承多个特定业务接口将比直接加载客户所需所有方法有效。

以上四个原则是面向对象中常常用到的原则。此外，除上述四原则外，还有一些常用的经验诸如类结构层次以三到四层为宜、类的职责明确化（一个类对应一个具体职责）等可供我们在进行面向对象设计参考。但就上面的几个原则看来，我们看到这些类在几何分布上呈现树型拓扑的关系，这是一种良好、开放式的线性关系、具有较低的设计复杂度。一般说来，在软件设计中我们应当尽量避免出现带有闭包、循环的设计关系，它们反映的是较大的耦合度和设计复杂化。

Tags: 面向对象, 原则

Misc | 评论:0 | 阅读:23505

javascript实现函数重载的深入探索

Submitted by gouki on 2008, April 27, 11:15 PM

 

COPY自一个网站，该网站声明此文章来自CSDN，代码没有仔细研读，但担心以后可能会用到。先MARK一下，做个记录。所以……

直接为我的博客加点料，原作者看到此文时，如觉不适，请通知删除。谢谢

JavaScript代码
  1. <script>   
  2. function Point2D(x, y)   
  3. {   
  4.  this.x = x;   
  5.  this.y = y;   
  6.  Point2D.prototype.quadrant = function()   
  7.  {   
  8.   if (x > 0 && y > 0) return "I";   
  9.   else if (x < 0 && y > 0) return "II";   
  10.   else if (x < 0 && y < 0) return "III";   
  11.   else if (x > 0 && y < 0) return "IV";   
  12.   else if (x == 0) return "x-axis";   
  13.   else if (y == 0) return "y-axis";   
  14.   else throw new Error();   
  15.  }   
  16.  Point2D.prototype.toVector = function()   
  17.  {   
  18.   return new Vector2D(x, y);   
  19.  }   
  20.  Point2D.prototype.distance = function() //求距离   
  21.  {   
  22.   if (arguments.length == 1 && arguments[0] instanceof Point2D)    
  23.   {   
  24.    return this._point_distance.apply(this, arguments);   
  25.   }   
  26.   else if (arguments.length == 1 && arguments[0] instanceof Vector2D)    
  27.   {   
  28.    return this._vector_distance.apply(this, arguments);   
  29.   }   
  30.   else  
  31.   {   
  32.    throw new Error("Argument Error!");   
  33.   }   
  34.  }   
  35.  Point2D.prototype._point_distance = function(p)  //求两点之间的距离(函数重载)   
  36.  {   
  37.   return (new Vector2D(p,this)).length();   
  38.  }   
  39.  Point2D.prototype._vector_distance = function(v)  //求点到向量的距离(函数重载)   
  40.  {   
  41.   var v1 = new Vector2D(this, v.start);   
  42.   var v2 = new Vector2D(this, v.end);   
  43.   
  44.   var area = Math.abs(v1.cross(v2));  //平行四边形面积 = v1 X v2 = |v1v2|sin(v1,v2)   
  45.      
  46.   return area / v.length();   //平行四边形面积除以底边长度即为点到向量的距离   
  47.  }   
  48. }   
  49. function Vector2D()   
  50. {   
  51.  if (arguments.length == 2 && arguments[0] instanceof Point2D && arguments[1] instanceof Point2D)   
  52.  {   
  53.   _point_point_Vector2D.apply(this, arguments);   
  54.  }   
  55.  else if (arguments.length == 2 && !isNaN(arguments[0]) && !isNaN(arguments[1]))   
  56.  {   
  57.   _double_double_Vector2D.apply(this, arguments);   
  58.  }   
  59.  else if (arguments.length == 4 && !isNaN(arguments[0]) && !isNaN(arguments[1])    
  60.   && !isNaN(arguments[2]) && !isNaN(arguments[3]))   
  61.  {   
  62.   _double_double_double_double_Vector2D.apply(this, arguments);   
  63.  }   
  64.  else  
  65.  {   
  66.   throw new Error("Argument Error!");   
  67.  }   
  68. }   
  69. function _point_point_Vector2D(p1, p2)      
  70. {   
  71.  this.start = p1;   
  72.  this.end = p2;   
  73.  Vector2D.prototype.length = function() //求向量的长度   
  74.  {   
  75.   return Math.sqrt(this.pond_x() * this.pond_x() + this.pond_y() * this.pond_y());   
  76.  }   
  77.  Vector2D.prototype.pond_x = function() //x方向分量   
  78.  {   
  79.   return this.start.x - this.end.x;   
  80.  }   
  81.  Vector2D.prototype.pond_y = function()   
  82.  {   
  83.   return this.start.y - this.end.y;   
  84.  }   
  85.  Vector2D.prototype.cross = function(v)   //求向量的交积 P1 X P2 = x1y2 - x2y1   
  86.  {   
  87.   return this.pond_x() * v.pond_y() - v.pond_x() * this.pond_y();   
  88.  }   
  89. }   
  90. function _double_double_Vector2D(x,y) //重载构造函数Vector2D   
  91. {   
  92.  this.pointPairs = new Array();   
  93.  this.pointPairs[0] = new Point2D(0, 0);   
  94.  this.pointPairs[1] = new Point2D(x, y);   
  95.   
  96.  _point_point_Vector2D.apply(this, this.pointPairs);   
  97. }   
  98. function _double_double_double_double_Vector2D(x1, y1, x2, y2)  //重载构造函数Vector2D   
  99. {   
  100.  this.pointPairs = new Array();   
  101.  this.pointPairs[0] = new Point2D(x1, y1);   
  102.  this.pointPairs[1] = new Point2D(x2, y2);   
  103.   
  104.  _point_point_Vector2D.apply(this, this.pointPairs);   
  105. }   
  106. var p1 = new Point2D(0,0);   
  107. var p2 = new Point2D(10,10);   
  108. var v1 = new Vector2D(p1,p2);  //通过两个点(p1,p2)的方式来构造向量V1   
  109. alert("向量v1长度:"+v1.length());   
  110. var v2 = new Vector2D(0,0,5,5);  //通过四个坐标(x1,y1,x2,y2)的方式来构造向量V2   
  111. alert("向量v2长度:"+v2.length());   
  112. var v3 = new Vector2D(0,10);  //通过指定终点的方式来构造向量V3   
  113. alert("向量v3长度:"+v3.length());   
  114. alert("向量v1与v2的交积:"+v1.cross(v2));  //求V1 X V2 (因为平行，所以结果为0)   
  115.   
  116. var p3 = new Point2D(10,0);   
  117. alert("点p1与p3的距离:"+p1.distance(p3));   
  118. alert("点p3与向量v1的距离:"+p3.distance(v1));   
  119. </script>  

 

Tags: js, 重载

Javascript | 评论:0 | 阅读:26795

全面理解javascript的caller,callee,call,apply概念(修改版) ［转］

Submitted by gouki on 2008, April 27, 11:06 PM

我的前言：

在写代码的时候，不可避免的会用到javascript，可是对它又不是很熟悉，让我再从头到尾看一遍代码简直就是一种折磨。这时，google就体现出他的作用了。

javascript不象PHP，它的函数取参数虽然也是通过arguments来取，但效果和PHP是两样的，PHP有func_get_args等三个函数来分别取得数字、列表、全部参数。而javascript怎么处理呢？

请看下面的文章，作者老狼，网址是：http://laolang.xtmm.cn，由于未经老狼同意，如果觉得有侵犯，请告知，我会尽快删除。

Arguments

该对象代表正在执行的函数和调用它的函数的参数。

[function.]arguments[n]
参数function ：选项。当前正在执行的 Function 对象的名字。 n ：选项。要传递给 Function 对象的从0开始的参数值索引。
说明

Arguments是进行函数调用时，除了指定的参数外，还另外创建的一个隐藏对象。Arguments是一个类似数组但不是数组的对象，说它类似数组是因为其具有数组一样的访问性质及方式，可以由arguments[n]来访问对应的单个参数的值，并拥有数组长度属性length。还有就是arguments对象存储的是实际传递给函数的参数，而不局限于函数声明所定义的参数列表，而且不能显式创建 arguments 对象。arguments 对象只有函数开始时才可用。下边例子详细说明了这些性质:


//arguments 对象的用法。
function ArgTest(a, b){
var i, s = "The ArgTest function expected ";
var numargs = arguments.length; // 获取被传递参数的数值。
var expargs = ArgTest.length; // 获取期望参数的数值。
if (expargs < 2)
s += expargs + " argument. ";
else
s += expargs + " arguments. ";
if (numargs < 2)
s += numargs + " was passed.";
else
s += numargs + " were passed.";
s += "\n\n"
for (i =0 ; i < numargs; i++){ // 获取参数内容。
s += " Arg " + i + " = " + arguments[i] + "\n";
}
return(s); // 返回参数列表。
}

在此添加了一个说明arguments不是数组(Array类)的代码:


Array.prototype.selfvalue = 1;
alert(new Array().selfvalue);
function testAguments(){
alert(arguments.selfvalue);
}

运行代码你会发现第一个alert显示1，这表示数组对象拥有selfvalue属性，值为1，而当你调用函数testAguments时，你会发现显示的是“undefined”，说明了不是arguments的属性，即arguments并不是一个数组对象。
在此附加上大家推荐的一个简单方法：

alert(arguments instanceof Array);
alert(arguments instanceof Object);


caller
返回一个对函数的引用，该函数调用了当前函数。
functionName.caller
functionName 对象是所执行函数的名称。
说明
对于函数来说，caller 属性只有在函数执行时才有定义。如果函数是由顶层调用的，那么 caller 包含的就是 null 。如果在字符串上下文中使用 caller 属性，那么结果和 functionName.toString 一样，也就是说，显示的是函数的反编译文本。
下面的例子说明了 caller 属性的用法：

// caller demo {
function callerDemo() {
if (callerDemo.caller) {
var a= callerDemo.caller.toString();
alert(a);
} else {
alert("this is a top function");
}
}
function handleCaller() {
callerDemo();
}

callee

返回正被执行的 Function 对象，也就是所指定的 Function 对象的正文。

[function.]arguments.callee
可选项 function 参数是当前正在执行的 Function 对象的名称。

说明

callee 属性的初始值就是正被执行的 Function 对象。

callee 属性是 arguments 对象的一个成员，它表示对函数对象本身的引用，这有利于匿名
函数的递归或者保证函数的封装性，例如下边示例的递归计算1到n的自然数之和。而该属性
仅当相关函数正在执行时才可用。还有需要注意的是callee拥有length属性，这个属性有时候
用于验证还是比较好的。arguments.length是实参长度，arguments.callee.length是
形参长度，由此可以判断调用时形参长度是否和实参长度一致。

示例


//callee可以打印其本身
function calleeDemo() {
alert(arguments.callee);
}
//用于验证参数
function calleeLengthDemo(arg1, arg2) {
if (arguments.length==arguments.callee.length) {
window.alert("验证形参和实参长度正确！");
return;
} else {
alert("实参长度：" +arguments.length);
alert("形参长度： " +arguments.callee.length);
}
}
//递归计算
var sum = function(n){
if (n <= 0)
return 1;
else
return n ＋arguments.callee(n - 1)
}
比较一般的递归函数：

var sum = function(n){
if (1==n) return 1;
else return n + sum (n-1);

调用时：alert(sum(100));
其中函数内部包含了对sum自身的引用，函数名仅仅是一个变量名，在函数内部调用sum即相当于调用
一个全局变量，不能很好的体现出是调用自身，这时使用callee会是一个比较好的方法。


apply and call

它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数方式有所区别：

apply(thisArg,argArray);

call(thisArg[,arg1,arg2…] ]);

即所有函数内部的this指针都会被赋值为thisArg，这可实现将函数作为另外一个对象的方法运行的目的

apply的说明

如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
如果没有提供 argArray 和 thisArg任何一个参数，那么 Global 对象将被用作 thisArg，
并且无法被传递任何参数。

call的说明

call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisArg指定的新对象。
如果没有提供 thisArg参数，那么 Global 对象被用作 thisArg

相关技巧：

应用call和apply还有一个技巧在里面，就是用call和apply应用另一个函数（类）以后，当前的
函数（类）就具备了另一个函数（类）的方法或者是属性，这也可以称之为“继承”。看下面示例:

// 继承的演示
function base() {
this.member = " dnnsun_Member";
this.method = function() {
window.alert(this.member);
}
}
function extend() {
base.call(this);
window.alert(member);
window.alert(this.method);
}

上面的例子可以看出，通过call之后，extend可以继承到base的方法和属性。



顺便提一下，在javascript框架prototype里就使用apply来创建一个定义类的模式，

其实现代码如下：

var Class = {
create: function() {
return function() {
this.initialize.apply(this, arguments);
}
}
}
解析：从代码看,该对象仅包含一个方法：Create，其返回一个函数，即类。但这也同时是类的
构造函数，其中调用initialize，而这个方法是在类创建时定义的初始化函数。通过如此途径，
就可以实现prototype中的类创建模式

示例：

var vehicle=Class.create();
vehicle.prototype={
initialize:function(type){
this.type=type;
}
showSelf:function(){
alert("this vehicle is "+ this.type);
}
}

var moto=new vehicle("Moto");
moto.showSelf();


更详细的关于prototype信息请到其官方网站查看。

Javascript | 评论:0 | 阅读:22916

Records:3129«‹605606607608609610611612613614›»