JavaScript面试后的重新思考

JavaScript没那么简单
服务器君一共花费了316.671 ms进行了6次数据库查询,努力地为您提供了这个页面。
试试阅读模式?希望听取您的建议

写此文目的是为了让更多的程序员理解javascript的一些概念,对,是理解,而不是了解。我们已经了解得够多了,该是向深入理解的方向靠拢的时候了。

为什么这么说,前些日子收到面试邀请,那就去试试呗,有几年没有面试过了吧。和面试官坐在沙发上,聊天式的他问我答,以下就是几个javascript方面的问题:

请创建一个对象,包括几个公有属性,接下来是为对象创建一个公有方法,然后为对象创建几个私有属性,一个私有方法。

说实话,这几个问题我默名其妙,要是他让我用jquery写个拖动插件什么的,我估计我能写挺好,原生的javascript,晕,虽然我看过jquery源码解读,但这些基本概念要命。

本文的例子输出使用如下方法,便于查看:

function dwn(s)
{
	document.write(s+"<br />");
}

function

从一开始接触到js就感觉好灵活,每个人的写法都不一样,比如一个function就有N种写法,如:

function showMsg(){}
var showMsg = function(){}
showMsg = function(){}

似乎没有什么区别,都是一样的嘛,真的是一样的吗,大家看看下面的例子:

///------------------------------------------------------------------------------------------------
//函数定义:命名函数(声明式),匿名函数(引用式)
//声明式,定义代码先于函数执行代码被解析
function t1()
{
	dwn("t1");
}
t1();
function t1()
{
 	dwn("new t1");
}
t1();
//引用式,在函数运行中进行动态解析
var t1 = function(){
 	dwn("new new t1");
}
t1();
var t1 = function(){
	dwn("new new new t1");
}
t1();
//以上输出:new t1,new t1,new new t1,new new new t1

可能想着应该是输出t1,new t1,new newt1,new new new t1,结果却并不是这样,应该理解这句话:声明式,定义代码先于函数执行代码被解析。

如果深入一步,应该说是scope链问题,实际上前面两个方法等价于window.t1,可以理解为t1是window的一个公有属性,被赋了两次值,以最后一次赋值为最终值。

而后面两个方法,可以理解为是t1是个变量,第四个方法的var去掉之后的结果仍然不会改变。

然而,当第四个方法改成function t1(){}这样的声明式时,结果变成了new new new t1,new new new t1,new new t1,new new t1 前面两个按照我的理解可以很好的理解为什么是这个答案,第三个也可以理解,但是最后一个输出让我比较纠结。

另外匿名函数还有(function(){...})()这样的写法,最后一个括号用于参数输入。

还有var t1=new function(){..}这样的声明,实际上t1已经是一个对象了。

var t2 = new function()
{
	var temp = 100; //私有成员
	this.temp = 200; //公有成员,这两个概念会在第三点以后展开说明
	return temp + this.temp;
}
alert(typeof(t2));   //object
alert(t2.constructor());  //300

除此之外,还有使用系统内置函数对象来构建一个函数,例:

//这个位置加不加new结果都一样,WHY
var t3 = new Function('var temp = 100; this.temp = 200; return temp + this.temp;'); 
alert(typeof(t3)); //function
alert(t3());  //300

创建对象

首先我们理解一下面向对象编程(Object-Oriented Programming,OOP),使用OOP技术,常常要使用许多代码模块,每个模块都提供特定的功能,每个模块都是孤立的,甚至与其它模块完全独立。这种模块化编程方法提供了非常大的多样性,大大增加了代码的重用机会。可以举例进一步说明这个问题,假定计算机上的一个高性能应用程序是一辆一流赛车。如果使用传统的编程技巧,这辆赛车就是一个单元。如果要改进该车,就必须替换整个单元,把它送回厂商,让汽车专家升级它,或者购买一个新车。如果使用OOP技术,就只需从厂商处购买新的引擎,自己按照说明替换它,而不必用钢锯切割车体。

不过大部分的论点是,javascript并不是直接的面向对象的语言,但是通过模拟可以做到很多面向对象语言才能做到的事,如继承,多态,封装,javascript都能干(没有做不到,只是想不到):

///-----------------------------------------------
//以下三种构造对象的方法
//new Object,实例化一个Object
var a = new Object();
a.x=1, a.y=2;
//对象直接量
var b = {x:1,y:2};
//定义类型
function Point(x,y)
{ 
	//类似于C#中的类
 	this.x=x;
 	this.y=y;
}
var p = new Point(1,2); //实例化类

第一种方法通过构造基本对象直接添加属性的方法来实现,第二种和第一种差不多,可以看成是第一种方法的快捷表示法。第三种方法中,可以以"类"为基础,创造多个类型相同的对象。

对象属性的封装(公有和私有)

以例子来说明:

function List()
{
	//私有成员,在对象外无法访问,如果此处无var声明,则m_elements将变成全局变量,这样外部是可以直接访问到的,如alert(m_elements[0])
    var m_elements=[]; 
	m_elements=Array.apply(m_elements,arguments);
 	//此处模拟getter,使用时alist.length;
	//等价于getName()方式:this.length=function(){return m_elements.length;},使用时alist.length();
	//公有属性,可以通过"."运算符或下标来访问
	this.length = {
  		valueOf:function(){
   			return m_elements.length;
  		},
  		toString:function(){
   			return m_elements.length;
  		}
 	}
 	//公有方法,此方法使用得alert(alist)相当于alert(alist.toString())
	this.toString=function(){ 
	return m_elements.toString();
}
//公有方法
this.add=function(){
	m_elements.push.apply(m_elements,arguments);
}
//私有方法如下形式,这里涉及到了闭包的概念,接下来继续说明
//var add=function()或function add()
//{
	//m_elements.push.apply(m_elements,arguments);
//}
}
var alist=new List(1,2,3);
dwn(alist);  //=alert(alist.toString()),输出1,2,3
dwn(alist.length); //输出3
alist.add(4,5,6); 
dwn(alist);  //输出1,2,3,4,5,6
dwn(alist.length); //输出6

属性和方法的类型

javascript里,对象的属性和方法支持4种不同的类型:private property(私有属性),dynamic public property(动态公有属性),static public property/prototype property(静态公有属性或原型属性),static property(静态属性或类属性)。私有属性对外界完全不具备访问性,可以通过内部的getter和setter(都是模拟);动态公有属性外界可以访问,每个对象实例持有一个副本,不会相互影响;原型属性每个对象实例共享唯一副本;类属性不作为实例的属性,只作为类的属性。

以下是例子:

///------------------------------------------------------------------------------------------------
//动态公有类型,静态公有类型(原型属性)
function myClass()
{
	var p=100; //private property
	this.x=10;  //dynamic public property
}
myClass.prototype.y=20; 
//static public property or prototype property,动态为myClass的原型添加了属性,将作用于所有实例化了的对象,注意这里用到了prototype,这是一个非常有用的东东
//要想成为高级javascript阶段,prototype和闭包必须得理解和适当应用
myClass.z=30; //static property
var a=new myClass();
dwn(a.p) //undefined
dwn(a.x) //10
dwn(a.y) //20
a.x=20;
a.y=40;
dwn(a.x); //20
dwn(a.y); //40
delete(a.x); //删除对象a的属性x
delete(a.y); //删除对象a的属性y
dwn(a.x); //undefined
dwn(a.y); //20 静态公有属性y被删除后还原为原型属性y
dwn(a.z); //undefined 类属性无法通过对象访问
dwn(myClass.z);

原型(prototype)

这里只讲部分,prototype和闭包都不是几句话都能讲清楚的,如果这里可以给你一些启蒙,则万幸矣。习语"照猫画虎",这里的猫就是原型,虎是类型,可以表示成:虎.prototype=某只猫 or 虎.prototype=new 猫()。因为原型属性每个对象实例共享唯一副本,所以当实例中的一个调整了一个原型属性的值时,所有实例调用这个属性时都将发生变化,这点需要注意。

以下是原型关系的类型链:

function ClassA(){
}
ClassA.prototype=new Object();
function ClassB(){
}
ClassB.prototype=new ClassA();
function ClassC(){
}
ClassC.prototype=new ClassB();
var obj=new ClassC();
dwn(obj instanceof ClassC); //true
dwn(obj instanceof ClassB); //true
dwn(obj instanceof ClassA); //true
dwn(obj instanceof Object); //true
//带默认值的Point对象:
function Point2(x,y){
	if (x) this.x=x;
	if (y) this.y=y;
}
//设定Point2对象的x,y默认值为0
Point2.prototype.x=0;
Point2.prototype.y=0;
//p1是一个默认(0,0)的对象
var p1=new Point2(); //可以写成var p1=new Point2也不会出错,WHY
//p2赋值
var p2=new Point2(1,2);
dwn(p1.x+","+p1.y); //0,0
dwn(p2.x+","+p2.y); //1,2
delete对象的属性后,原型属性将回到初始化的状态:
function ClassD(){
	this.a=100;
	this.b=200;
	this.c=300
}
ClassD.prototype = new ClassD(); //将ClassD原有的属性设为原型,包括其值
ClassD.prototype.reset = function(){ //将非原型属性删除
	for (var each in this) 
    {
  		delete this[each];
 	}
}
var d = new ClassD();
dwn(d.a); //100
d.a*=2;
d.b*=2;
d.c*=2;
dwn(d.a); //200
dwn(d.b); //400
dwn(d.c); //600
d.reset(); //删掉非原型属性,所有回来原型
dwn(d.a); //100
dwn(d.b); //200
dwn(d.c); //300

继承

如果两个类都是同一个实例的类型,那么它们之间存在着某种关系,我们把同一个实例的类型之间的泛化关系称为继承。C#和JAVA中都有这个,具体的理解就不说了。

在javascript中,并不直接从方法上支持继承,但是就像前面说的,可以模拟。

方法可以归纳为四种:构造继承法,原型继承法,实例继承法和拷贝继承法。融会贯通之后,还有混合继续法,这是什么法,就是前面四种挑几种混着来~

以下例子涉及到了apply,call和一些Array的用法:

构造继续法例子

//定义一个Collection类型
function Collection(size)
{
	this.size = function(){return size};  //公有方法,可以被继承
}
 
Collection.prototype.isEmpty = function(){   //静态方法,不能被继承
	return this.size() == 0;
}
 
//定义一个ArrayList类型,它"继承"Collection类型
function ArrayList()
{
	var m_elements = []; //私有成员,不能被继承
	m_elements = Array.apply(m_elements, arguments);
	//ArrayList类型继承Collection
  	this.base = Collection;
  	this.base.call(this, m_elements.length);
 
  	this.add = function()
  	{
   		return m_elements.push.apply(m_elements, arguments);
  	} 
  	this.toArray = function()
  	{
   		return m_elements;
  	}
}
ArrayList.prototype.toString = function()
{
	return this.toArray().toString();
}
//定义一个SortedList类型,它继承ArrayList类型
function SortedList()
{
	//SortedList类型继承ArrayList
	this.base = ArrayList;
	this.base.apply(this, arguments);
	this.sort = function()
	{
   		var arr = this.toArray();
   		arr.sort.apply(arr, arguments);
  	}
}
//构造一个ArrayList
var a = new ArrayList(1,2,3);
dwn(a);
dwn(a.size()); //a从Collection继承了size()方法
dwn(a.isEmpty); //但是a没有继承到isEmpty()方法
//构造一个SortedList
var b = new SortedList(3,1,2);
b.add(4,0); //b 从ArrayList继承了add()方法
dwn(b.toArray()); //b 从ArrayList继承了toArray()方法
b.sort();  //b 自己实现的sort()方法
dwn(b.toArray());
dwn(b);
dwn(b.size()); //b从Collection继承了size()方法

原型继承法例子

//定义一个Point类型
function Point(dimension)
{
	this.dimension = dimension;
}
//定义一个Point2D类型,"继承"Point类型
function Point2D(x, y)
{
	this.x = x;
	this.y = y;
}
Point2D.prototype.distance = function()
{
	return Math.sqrt(this.x * this.x + this.y * this.y);
}
Point2D.prototype = new Point(2);  //Point2D继承了Point
//定义一个Point3D类型,也继承Point类型
function Point3D(x, y, z)
{
	this.x = x;
	this.y = y;
	this.z = z;
}
Point3D.prototype = new Point(3);  //Point3D也继承了Point
 
//构造一个Point2D对象
var p1 = new Point2D(0,0);
//构造一个Point3D对象
var p2 = new Point3D(0,1,2);
dwn(p1.dimension);
dwn(p2.dimension);
dwn(p1 instanceof Point2D); //p1 是一个 Point2D
dwn(p1 instanceof Point); //p1 也是一个 Point
dwn(p2 instanceof Point); //p2 是一个Point

以上两种方法是最常用的。

实例继承法例子

在说此法例子之前,说说构造继承法的局限,如下:

function MyDate()
{
	this.base = Date;
	this.base.apply(this, arguments);
}
var date = new MyDate();
//undefined,date并没有继承到Date类型,所以没有toGMTString方法
alert(date.toGMTString); 

核心对象的某些方法不能被构造继承,原因是核心对象并不像我们自定义的一般对象那样在构造函数里进行赋值或初始化操作换成原型继承法呢?,如下:

function MyDate(){}
MyDate.prototype=new Date();
var date=new MyDate();
//'[object]'不是日期对象,仍然没有继承到Date类型!
alert(date.toGMTString); 

现在,换成实例继承法:

function MyDate()
{
	//instance是一个新创建的日期对象
    var instance = new Date(); 
	instance.printDate = function(){
		document.write("<p> "+instance.toLocaleString()+"</p> ");
	} 
	//对instance扩展printDate()方法
  	return instance;  //将instance作为构造函数的返回值返回
}
var myDate = new MyDate();
//这回成功输出了正确的时间字符串,看来myDate已经是一个Date的实例了,继承成功
dwn(myDate.toGMTString()); 
//如果没有return instance,将不能以下标访问,因为是私有对象的方法
myDate.printDate(); 

拷贝继承法例子

Function.prototype.extends = function(obj)
{
	for(var each in obj)
 	{
		this.prototype[each] = obj[each]; 
  		//对对象的属性进行一对一的复制,但是它又慢又容易引起问题
		//所以这种"继承"方式一般不推荐使用
	}
}
var Point2D = function(){
	//……
}
Point2D.extends(new Point())
{
	//……
}

这种继承法似乎是用得很少的。

混合继承例子

function Point2D(x, y)
{
	this.x = x;
	this.y = y;
}
function ColorPoint2D(x, y, c)
{
	Point2D.call(this, x, y); //这里是构造继承,调用了父类的构造函数
	//从前面的例子看过来,这里等价于
	//this.base=Point2D;
	//this.base.call(this,x,y);
	this.color = c;
}
ColorPoint2D.prototype = new Point2D();  //这里用了原型继承,让ColorPoint2D以Point2D对象为原型

本文地址:http://www.nowamagic.net/librarys/veda/detail/488,欢迎访问原出处。

不打个分吗?

转载随意,但请带上本文地址:

http://www.nowamagic.net/librarys/veda/detail/488

如果你认为这篇文章值得更多人阅读,欢迎使用下面的分享功能。
小提示:您可以按快捷键 Ctrl + D,或点此 加入收藏

大家都在看

阅读一百本计算机著作吧,少年

很多人觉得自己技术进步很慢,学习效率低,我觉得一个重要原因是看的书少了。多少是多呢?起码得看3、4、5、6米吧。给个具体的数量,那就100本书吧。很多人知识结构不好而且不系统,因为在特定领域有一个足够量的知识量+足够良好的知识结构,系统化以后就足以应对大量未曾遇到过的问题。

奉劝自学者:构建特定领域的知识结构体系的路径中再也没有比学习该专业的专业课程更好的了。如果我的知识结构体系足以囊括面试官的大部分甚至吞并他的知识结构体系的话,读到他言语中的一个词我们就已经知道他要表达什么,我们可以让他坐“上位”毕竟他是面试官,但是在知识结构体系以及心理上我们就居高临下。

所以,阅读一百本计算机著作吧,少年!

《致加西亚的信》 阿尔伯特·哈伯德(Hubbard.E.) (作者), 赵立光 (译者), 艾柯 (译者)

《致加西亚的信(经典盒装版)》内容简介:美西战争爆发以后,美国必须立即与古巴起义军首领加西亚取得联系,并获得他的合作。但当时,加西亚身在古巴的深山里——没有人知道他的确切地点,所以没法与他取得联系。这时,有人向总统推荐一个名叫罗文的人,说他有办法找到加西亚,而且也只有他才能找得到。他们找来罗文,交给他一封写给加西亚的信。三周后,罗文徒步走过一个危机四伏的国家,最终把那封信交给了加西亚。 此后,罗文的事迹被传为佳话,“送信”成为了敬业、忠诚、勤奋的象征,罗文便成了每个领导都想找到的人和每个员工都应该学习和效仿的榜样。

更多计算机宝库...