没有眼泪
Don't Cry!
posts - 13,comments - 44,trackbacks - 0
在javaweb开发过程中get和post乱码是一个老生常谈的话题了,相信人人都遇到过。网上的文章也很多,但往往是看的越多就越糊涂,有些东西只有自己了然于心才能真正地明白。下面就写一篇文章,就乱码产生的过程分析一下。
为什么会产生乱码?

1.   为什么会产生乱码?

因为浏览器不允许提交非ASCII字符,如果提交了非ASCII,则浏览器自动对其进行编码,将它们转换为ASCII字符。根据浏览器的不同,转换时使用的编码也不同,比如有些浏览器会使用utf-8进行编码,而有些会使用gbk进行编码。

2.   浏览器为什么不允许提交非ASCII字符?

以下是我个人观点,仅供参考。

因为浏览器和服务器通信,传输的都是字节。而我们在页面提交的都是字符,所以浏览器底层就有一个将字符转换为字节的过程,这个过程涉及到编码,浏览器到底是用utf-8gbk还是iso-8859-1将字符转换为字节呢?我想应该是iso-8859-1,因为这是西欧默认使用的编码。何况,也没有任何理由使用前两种编码格式。但是iso-8859-1编码是不能识别中文以及其他非ASCII字符的,所以如果字符中存在这类字符,那么将字符转换为字节的过程中势必会产生乱码。为了避免这种情况的发生,浏览器自动对非ASCII字符进行了编码,将这类字符转换为ASCII字符,这样就能避免乱码问题。

3.   GETPOST提交表单,分别根据什么对非ASCII字符进行编码?

GET

情况比较复杂,不同浏览器也不一样,有的使用gbk,有的使用utf-8不好一概而论。

POST

浏览器会根据网页编码对表单中的数据编码。比如我们在jsp页面第一行所写的:<%@page contentType="text/html;charset=UTF-8"%>。那么这个网页响应给客户端后使用的就是utf-8编码,那么post时使用的也是这个编码。

编码后的格式可以参考java中的URLEncoder.encode方法编码的结果。

4.   服务器底层如何处理提交的数据。

上面2已经提到,客户端和服务器端传输的是字节,那么服务器端接收到的原始数据就是字节。但是我们的程序通常需要从服务器获取字符,而不是字节,所以服务器端必须将字节转换为字符。这里也涉及编码,服务器采取什么编码方式将字节转换为字符?我想也是iso-8859-1,这样和客户端的编码方式一致,不会产生乱码,相当于一个还原字符的过程。这里有个问题,比如客户端发送:name=%D6%D0%B9%FA,那么服务器端还原后也是:name=%D6%D0%B9%FA。那么我们使用request.getParameter(“name”)如何能得到正确的值呢?难道要我们自己再进行转换?答案是:NO。根据Servlet规范,Servlet中获取数据的方法会按照指定的字符集解码。指定的字符集是什么?默认是iso-8859-1。正是因为使用了iso-8859-1解码我们发送的参数,导致了乱码的产生,这里才是产生乱码的源头。具体解码的过程可以看看javaURLDecode.decode方法。既然知道了产生乱码的原因是因为服务器默认使用iso-8859-1解码,那我们就得想办法更改服务器使用的解码编码。好在服务器已经提供给我们修改的方式了,我们可以在服务器中进行配置,比如Tomcat可以在server.xml中进行配置,比如:URIEncoding="GBK"这样服务器就会使用gbk编码解码,这种方式主要针对GET提交的数据,对于POST更常用的是request.setCharacterEncoding(String charset)设置解码编码。

5.   为了避免乱码,客户端应该如何做?

GET

对于含有非ASCII字符的URL自己进行编码,比如使用javascript中的方法进行编码。这样就不需要浏览器为我们编码了,从而解决了浏览器编码的不确定性。

POST

只要正确设置网页编码即可。

posted @ 2013-07-27 16:56 zhangchao 阅读(4117) | 评论 (2)编辑 收藏
     摘要: 工作中经常遇到java编码问题,由于缺乏研究,总是无法给出确切的答案,这个周末在网上查了一些资料,在此做些汇总。     问题一:在java中读取文件时应该采用什么编码? Java读取文件的方式总体可以分为两类:按字节读取和按字符读取。按字节读取就是采用InputStream.read()方法来读取字节,然后保存到一个byte[]数组中,最后经常用new Stri...  阅读全文
posted @ 2011-05-26 10:35 zhangchao 阅读(37249) | 评论 (19)编辑 收藏
Servlet/JSP技术和ASP、PHP等相比,由于其多线程运行而具有很高的执行效率。由于Servlet/JSP默认是以多线程模式执行的,所 以,在编写代码时需要非常细致地考虑多线程的安全性问题。然而,很多人编写Servlet/JSP程序时并没有注意到多线程安全性的问题,这往往造成编写 的程序在少量用户访问时没有任何问题,而在并发用户上升到一定值时,就会经常出现一些莫明其妙的问题。

  Servlet的多线程机制

Servlet体系结构是建立在Java多线程机制之上的,它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet 时,Servlet容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时,一般不会再实例化该 Servlet类,也就是有多个线程在使用这个实例。Servlet容器会自动使用线程池等技术来支持系统的运行,如图1所示。

  

  图1 Servlet线程池

  这样,当两个或多个线程同时访问同一个Servlet时,可能会发生多个线程同时访问同一资源的情况,数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题,会使所写的Servlet程序有难以发现的错误。

  Servlet的线程安全问题

  Servlet的线程安全问题主要是由于实例变量使用不当而引起的,这里以一个现实的例子来说明。

Import javax.servlet. *;
Import javax.servlet.http. *;
Import java.io. *;
Public class Concurrent Test extends HttpServlet {PrintWriter output;
Public void service (HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {String username;
Response.setContentType ("text/html; charset=gb2312");
Username = request.getParameter ("username");
Output = response.getWriter ();
Try {Thread. sleep (5000); //为了突出并发问题,在这设置一个延时
} Catch (Interrupted Exception e){}
output.println("用户名:"+Username+"<BR>");
}
}

该Servlet中定义了一个实例变量output,在service方法将其赋值为用户的输出。当一个用户访问该Servlet时,程序会正常的运 行,但当多个用户并发访问时,就可能会出现其它用户的信息显示在另外一些用户的浏览器上的问题。这是一个严重的问题。为了突出并发问题,便于测试、观察, 我们在回显用户信息时执行了一个延时的操作。假设已在web.xml配置文件中注册了该Servlet,现有两个用户a和b同时访问该Servlet(可 以启动两个IE浏览器,或者在两台机器上同时访问),即同时在浏览器中输入:

  a: http://localhost: 8080/servlet/ConcurrentTest? Username=a

  b: http://localhost: 8080/servlet/ConcurrentTest? Username=b

  如果用户b比用户a回车的时间稍慢一点,将得到如图2所示的输出:

  

  图2 a用户和b用户的浏览器输出

从图2中可以看到,Web服务器启动了两个线程分别处理来自用户a和用户b的请求,但是在用户a的浏览器上却得到一个空白的屏幕,用户a的信息显示在用 户b的浏览器上。该Servlet存在线程不安全问题。下面我们就从分析该实例的内存模型入手,观察不同时刻实例变量output的值来分析使该 Servlet线程不安全的原因。

  Java的内存模型JMM(Java Memory Model)JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计,系统存在一个主内存(Main Memory),Java中所有实例变量都储存在主存中,对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory),工作内存由缓存和堆栈两部分组成,缓存中保存的是主存中变量的拷贝,缓存可能并不总和主存同步,也就是缓存中变量的修改可能没有立刻写到 主存中;堆栈中保存的是线程的局部变量,线程之间无法相互直接访问堆栈中的变量。根据JMM,我们可以将论文中所讨论的Servlet实例的内存模型抽象 为图3所示的模型。

  

  图3 Servlet实例的JMM模型

  下面根据图3所示的内存模型,来分析当用户a和b的线程(简称为a线程、b线程)并发执行时,Servlet实例中所涉及变量的变化情况及线程的执行情况,如图4所示。

调度时刻 a线程 b线程
T1 访问Servlet页面
T2
访问Servlet页面
T3 output=a的输出username=a休眠5000毫秒,让出CPU
T4
output=b的输出(写回主存)username=b休眠5000毫秒,让出CPU
T5 在用户b的浏览器上输出a线程的username的值,a线程终止。  
T6
在用户b的浏览器上输出b线程的username的值,b线程终止。

  图4 Servlet实例的线程调度情况

从图4中可以清楚的看到,由于b线程对实例变量output的修改覆盖了a线程对实例变量output的修改,从而导致了用户a的信息显示在了用户b的 浏览器上。如果在a线程执行输出语句时,b线程对output的修改还没有刷新到主存,那么将不会出现图2所示的输出结果,因此这只是一种偶然现象,但这 更增加了程序潜在的危险性。

  设计线程安全的Servlet

  通过上面的分析,我们知道了实例变量不正确的使用是造成Servlet线程不安全的主要原因。下面针对该问题给出了三种解决方案并对方案的选取给出了一些参考性的建议。

  1、实现 SingleThreadModel 接口

该接口指定了系统如何处理对同一个Servlet的调用。如果一个Servlet被这个接口指定,那么在这个Servlet中的service方法将不 会有两个线程被同时执行,当然也就不存在线程安全的问题。这种方法只要将前面的Concurrent Test类的类头定义更改为:

Public class Concurrent Test extends HttpServlet implements SingleThreadModel {
…………
}

  2、同步对共享数据的操作

  使用synchronized 关键字能保证一次只有一个线程可以访问被保护的区段,在本论文中的Servlet可以通过同步块操作来保证线程的安全。同步后的代码如下:

…………
Public class Concurrent Test extends HttpServlet { …………
Username = request.getParameter ("username");
Synchronized (this){
Output = response.getWriter ();
Try {
Thread. Sleep (5000);
} Catch (Interrupted Exception e){}
output.println("用户名:"+Username+"<BR>");
}
}
}

  3、避免使用实例变量

  本实例中的线程安全问题是由实例变量造成的,只要在Servlet里面的任何方法里面都不使用实例变量,那么该Servlet就是线程安全的。

  修正上面的Servlet代码,将实例变量改为局部变量实现同样的功能,代码如下:

……
Public class Concurrent Test extends HttpServlet {public void service (HttpServletRequest request, HttpServletResponse
Response) throws ServletException, IOException {
Print Writer output;
String username;
Response.setContentType ("text/html; charset=gb2312");
……
}
}

对上面的三种方法进行测试,可以表明用它们都能设计出线程安全的Servlet程序。但是,如果一个Servlet实现了 SingleThreadModel接口,Servlet引擎将为每个新的请求创建一个单独的Servlet实例,这将引起大量的系统开销。 SingleThreadModel在Servlet2.4中已不再提倡使用;同样如果在程序中使用同步来保护要使用的共享的数据,也会使系统的性能大大 下降。这是因为被同步的代码块在同一时刻只能有一个线程执行它,使得其同时处理客户请求的吞吐量降低,而且很多客户处于阻塞状态。另外为保证主存内容和线 程的工作内存中的数据的一致性,要频繁地刷新缓存,这也会大大地影响系统的性能。所以在实际的开发中也应避免或最小化 Servlet 中的同步代码;在Serlet中避免使用实例变量是保证Servlet线程安全的最佳选择。从Java 内存模型也可以知道,方法中的临时变量是在栈上分配空间,而且每个线程都有自己私有的栈空间,所以它们不会影响线程的安全。

  小结

Servlet的线程安全问题只有在大量的并发访问时才会显现出来,并且很难发现,因此在编写Servlet程序时要特别注意。线程安全问题主要是由实 例变量造成的,因此在Servlet中应避免使用实例变量。如果应用程序设计无法避免使用实例变量,那么使用同步来保护要使用的实例变量,但为保证系统的 最佳性能,应该同步可用性最小的代码路径。


原文出处:http://www.feeten.cn/html/jsp/01/20090102181631103402.html
作者:佚名
posted @ 2009-05-31 10:06 zhangchao 阅读(312) | 评论 (0)编辑 收藏

File类是用来构造文件或文件夹的类,在其构造函数中要求传入一个String类型的参数,用于指示文件所在的路径.以前一直使用绝对路径作为参数,其实这里也可以使用相对路径.使用绝对路径不用说,很容易就能定位到文件,那么使用了相对路径jvm如何定位文件的呢?

按照jdk Doc上的说法绝对路径名是完整的路径名,不需要任何其他信息就可以定位自身表示的文件。相反,相对路径名必须使用来自其他路径名的信息进行解释。默认情况下,java.io 包中的类总是根据当前用户目录来分析相对路径名。此目录由系统属性 user.dir 指定,通常是 Java 虚拟机的调用目录.

相对路径顾名思义,相对于某个路径,那么究竟相对于什么路径我们必须弄明白.按照上面jdk文档上讲的这个路径是当前用户目录也就是java虚拟机的调用目录.更明白的说这个路径其实是我们在哪里调用jvm的路径.举个例子:

假设有一java源文件Example.javad盘根目录下,该文件不含package信息.我们进入命令行窗口,然后使用d:命令切换到d盘根目录下,然后用javac Example.java来编译此文件,编译无错后,会在d盘根目录下自动生成Example.class文件.我们在调用java Example来运行该程序.此时我们已经启动了一个jvm,这个jvm是在d盘根目录下被启动的,所以此jvm所加载的程序中File类的相对路径也就是相对这个路径的,d盘根目录:D:\.同时 当前用户目录也是D:\.System.getProperty(user.dir);系统变量user.dir存放的也是这个值.

我们可以多做几次试验,Example.class移动到不同路径下,同时在那些路径下,执行java Example命令启动jvm,我们会发现这个当前用户目录是不断变化的,它的路径始终和我们在哪启动jvm的路径是一致的.

搞清了这些,我们可以使用相对路径来创建文件,例如:

File file = new File(a.txt);

File.createNewFile();

假设jvm是在D:\下启动的,那么a.txt就会生成在D:\a.txt;

此外,这个参数还可以使用一些常用的路径表示方法,例如..\代表当前目录,这个目录也就是jvm启动路径.所以如下代码能得到当前目录完整路径:

File f = new File(“.”);

String absolutePath = f.getAbsolutePath();

System.out.println(absolutePath);//D:\

最后要说说在eclipse中的情况:

Eclipse中启动jvm都是在项目根路径上启动的.比如有个项目名为blog,其完整路径为:D:\work\IDE\workspace\blog.那么这个路径就是jvm的启动路径了.所以以上代码如果在eclipse里运行,则输出结果为” D:\work\IDE\workspace\blog.”

Tomcat中的情况.

如果在tomcat中运行web应用,此时,如果我们在某个类中使用如下代码:

File f = new File(“.”);

String absolutePath = f.getAbsolutePath();

System.out.println(absolutePath);

那么输出的将是tomcat下的bin目录.我的机器就是 D:\work\server\jakarta-tomcat-5.0.28\bin\.”,由此可以看出tomcat服务器是在bin目录下启动jvm.其实是在bin目录下的 catalina.bat”文件中启动jvm.

posted @ 2009-04-15 00:01 zhangchao 阅读(15627) | 评论 (10)编辑 收藏
通常所说的cookie实际上可以分为2,一种是由Cookie对象产生的保存在客户端硬盘上的持久化的cookie,另一种就是由session对象产生的保存在浏览器内存里的session cookie.session cookie的组成是形如: JSESSIONID=0EB8CEDE030A4B6FB5366317D8BF1978(tomcat).Session cookie何时产生?当新创建一个session对象时产生session cookie.当使用request.getSession()request.getSession(true)方法时,如果请求范围内根据jsessionid能够找到一个对应的session对象,则不产生session cookie也不返回给客户端保存,找不到则新创建一个session cookie并生成一个形如JSESSIONID=0EB8CEDE030A4B6FB5366317D8BF1978(tomcat)session cookie并放在本次响应头信息中返回给客户端保存,客户端之前保存的session cookie也将被这个session cookie所代替.session cookie不同的是,如果服务器端明确使用Cookie类来生成的持久化cookie将在每次响应中返回给客户端保存,不管客户端是否存在这个cookie.当浏览器接受cookie(不管是持久化cookie还是session cookie),在对同一站点进行访问时,会自动把这些cookie信息放在请求头信息中一起发送给服务器端.这样服务器端就能得到这些cookie来跟踪会话.向服务器端发送cookie这个过程对用户来是完全透明的,是浏览器自动进行的.
以上讨论是在浏览器接受cookie的情况下,下面谈谈浏览器禁用cookie的情况.
如果浏览器禁用了cookie,那么浏览器不会接收保存服务器端存在响应头中的cookie信息(ie6bug,会保存session cookie).浏览器再次访问同一站点时,请求头信息里也不会携带任何cookie信息的(因为浏览器根禁止了该功能).正因如此,服务器端接收不到客户端的cookie信息,也就无法识别客户端的身份,从而把它当作一个新的客户对待,也就会丢失以前的会话信息.在这种情况下服务器端使用request.getSession()request.getSession(true)方法时将会重新创建一个session.
那么如何在用户禁用了cookie的情况下维护会话呢?以上讨论我们已经知道,服务器端判断是新的会话还是旧的会话是根据请求头中是否有一个jsessionid.由于浏览器禁用了cookie从而不会自动向服务器发送这个参数,那么要维持会话就需要我们自己每次服务器发送请求时带上这个参数.url重写正是这样一种技术,只要在我们的代码中把所有向服务器发送请求的地方用response.encodeRedirectUrl(String arg0)包装一下,这样我们请求的url就会自动加上当前session对象产生的jsessionid.服务器端也能取得这个值从而识别客户端.
posted @ 2009-04-14 23:59 zhangchao 阅读(740) | 评论 (0)编辑 收藏
    splice方法是javascript中数组的一个方法,其功能是:可向数组删除并加入新的元素.其方法声明如下:
arrayObject.splice(index,howmany,element1,..,elementX)
index:必选项.指定在哪个位置加入/删除元素,必须是数字.
howmany:必选项.指定有多少元素应该被删除,必须是数字,可以是"0".
element1:可选.指定要加入到数组中的新元素.
elementX:可选.可以加入多个元素.
说明:如果howmany为0或"0",则该数组中将没有元素被删除,那么element1至elementX个参数将从index指定的位置插入到该数组中,数组中原位置的元素将后移.如果howmany不为0,则从index指定位置开始删除howmany个元素(包括index位置的元素),然后再从index开始插入element1至elementX个参数,数组中原位置的元素将后移.
例1:
<script type="text/javascript">
var arr 
= new Array(5);
arr[
0= "Jani";
arr[
1= "Hege";
arr[
2= "Stale";
arr[
3= "Kai Jim"
arr[
4= "Borge";
document.write(arr 
+ "<br />");
arr.splice(
2,0,"Lene");
document.write(arr 
+ "<br />");
</script>
输出结果为:
Jani,Hege,Stale,Kai Jim,Borge
Jani,Hege,Lene,Stale,Kai Jim,Borge
例2:
<script type="text/javascript">
var arr 
= new Array(5);
arr[
0= "Jani";
arr[
1= "Hege";
arr[
2= "Stale";
arr[
3= "Kai Jim";
arr[
4= "Borge";
document.write(arr 
+ "<br />");
arr.splice(
2,1,"Tove");
document.write(arr);
</script>
输出结果为:
Jani,Hege,Stale,Kai Jim,Borge
Jani,Hege,Tove,Kai Jim,Borge
例3:
<script type="text/javascript">
var arr 
= new Array(5);
arr[
0= "Jani";
arr[
1= "Hege";
arr[
2= "Stale";
arr[
3= "Kai Jim";
arr[
4= "Borge";
document.write(arr 
+ "<br />");
arr.splice(
2,3,"Tove");
document.write(arr);
</script>
输出结果为:
Jani,Hege,Stale,Kai Jim,Borge
Jani,Hege,Tove
posted @ 2008-05-28 12:58 zhangchao 阅读(2066) | 评论 (0)编辑 收藏
        终于到了要离开的一天,毕业之后来到这家公司,从一个毕业生成长为一个程序员,经历过许多辛酸与磨炼,回想往事,眼前浮现出曾经那一张张熟悉的面孔.谢谢曾经给过我帮助的同事与朋友,没有你们也没有今天的我,希望大家越来越好,也希望公司越来越好,也希望自己能有个美好的未来.
posted @ 2008-05-09 17:12 zhangchao 阅读(305) | 评论 (1)编辑 收藏
        众所周知,javascript中的继承是通过原型对象(prototype)来实现的.原型对象是由函数的构造函数创建,它所拥有的属性能被所有对象共享.初始时原型对象指向一个Object对象,并且定义了一个constructor属性,该属性指向定义该原型对象的构造函数本身,上述过程可以理解为以下代码:
function BaseClass() {
    document.write('This is BaseClass.');
}
BaseClass.prototype 
= new Object();
BaseClass.prototype.constructor 
= BaseClass;
因为原型对象的所有属性能被构造函数创建对象共享,所以创建的对象可以访问这里的constructor属性:
var c = new BaseClass();
document.write(c.constructor 
== BaseClass); //true
c.constructor(); //调用BaseClass函数,输出This is BaseClass.
由于对象本身也可以自定义属性,所以在读取对象属性时js先检查该对象是否定义了该属性,如果已经定义了则使用该属性,如果没有定义则再从其原型对象中读取该属性,所以如果对象自定义的属性和其原型中的属性存在重名则自定义属性"隐藏"了其原型对象中的同名属性.例:
c.constructor = function() {
    document.write('This is c');
}
c.constructor(); 
//This is c
加入上述代码之后再次调用c.constructor(),则会打印出"This is c".这是因为c已自定义constructor属性"隐藏"了其原型对象中的constructor属性.当然js保证了读写的不对称性,也就是说读取一个对象的属性时有可能要从其原型对象中去读取,但写一个对象的属性时却从不涉及其原型对象,无论在一个对象加入或修改多少属性这都不影响其原型对象中属性的本来面目.比如这里c自定义了constructor属性,但这一行为并不影响其原型对象中constructor指向其构造函数这一事实,如果再创建一个对象且不自定义constructor属性,再调用constructor则依然调用对象的构造函数,例:
var b = new BaseClass();
b.constructor(); 
//调用BaseClass函数,输出This is BaseClass.

很容易理解js为什么这样做,因为一个对象的行为不能影响到其他对象,否则将会造成混乱.
        理解上述规则之后让我们看看js中是如何通过原型对象实现继承的.当我们创建一个对象时,可以把该对象看成是由2部分组成的,一部分存储了该对象自己定义的属性(称为A部分),而另一个部分则存储了其构造函数所定义的原型对象引用(称为B部分),例如这里的BaseClass.prototype.当读取对象的属性时可以分为以下2步:
1.js先检查该对象引用所指向的内存区域的A部分是否存在该属性,如果存在则读出.
2.如果没有则再从B部分存储的引用(BaseClass.prototype)所指向的内存区域中读取该属性.

从步骤2开始这就是个不断往上寻找的过程,因为BaseClass.prototype所指向的内存区域也会分为A和B两个部分,如果再A部分也不存在该属性,则又会从其B部分所指向的内存区域去寻找该属性,而该内存区域也有A和B两个部分,如果A部分仍然不存在,则还要从B部分所指向的内存区域去寻找该属性,直到达到最顶层的Object类.所以在无形当中就形成了一条链,也就是我们常说的原型链.如果理解了这个过程我想也就能了解原型对象了.下面简单分析下b.constructor();的调用过程便于加深理解.
1.js会在b所指向的内存区域A部分读取constructor属性.
2.当发现没有该属性后再从其类的构造函数原型对象引用所指向的内存区域读取该属性.因为原型对象引用初始时指向一Object对象内存区域(BaseClass.prototype = new Object();)
3.再从此Object对象的A部分寻找constructor属性.
4.没有找到该属性则从其类的原型对象即Object.prototype中去寻找constructor.
5.如果找到该属性则调用.
6.否则,到达链的顶端,返回.
到此能很清楚的知道js中是如何实现继承的,如果我们自定义的类不想继承自Object,则可以修改其prototype的指向,可以让其指向任意一个类,这样也就实现了继承自定义类,但js中所有的类都继承自Object类,所以原型链的关系仍然存在.

posted @ 2008-05-09 16:43 zhangchao 阅读(855) | 评论 (3)编辑 收藏
    项目中经常使用createDelegate()方法来创建代理函数,从而改变当前函数中this的作用域.看下了源码,发现是通过js中的apply()方法来实现,想想也只能通过apply()或者call()方法来实现,因为js中只有这2个方法提供了改变当前函数内部this作用域的功能.此外,Ext中很多地方用到了call()和apply()方法,要想看懂源码,则必须先搞清这2个方法的用法.
    createDelegate方法声明为:
 1createDelegate : function(obj, args, appendArgs){
 2        var method = this;
 3        return function() {
 4            var callArgs = args || arguments;
 5            if(appendArgs === true){
 6                callArgs = Array.prototype.slice.call(arguments, 0);
 7                callArgs = callArgs.concat(args);
 8            }
else if(typeof appendArgs == "number"){
 9                callArgs = Array.prototype.slice.call(arguments, 0); // copy arguments first
10                var applyArgs = [appendArgs, 0].concat(args); // create method call params
11                Array.prototype.splice.apply(callArgs, applyArgs); // splice them in
12            }

13            return method.apply(obj || window, callArgs);
14        }
;
15    }
,
其中obj表示函数内部this作用域的范围,args是数组,appendArgs是"Boolean或Number",如果appendArgs是Boolean型的且值为true,那么args参数将跟在调用代理方法时传入的参数后面组成数组一起传入当前方法,否则只传入args,如果appendArgs为Number型,那么args将插入到appendArgs指定的位置.
注意点:
1.函数内部的arguments关键字是函数执行时动态创建的,用来存储调用函数时所传入参数.这里第4行的arguments   并不指调用createDelegate方法所传入的参数(obj,args,appendArgs),而是指调用return function()时所传入的参数,即调用代理函数时所传入的参数.而args和appendArgs就是调用createDelegate方法时所传入的参数.总的来说,函数是在定义它的作用域中执行,而不是在调用它的作用域中执行.但也有特殊,比如这里的arguments.
2.call和apply的区别.
二者的第一个参数都是函数内部this的作用域,call的参数只能作为一串参数传入,而apply可以传入数组或arguments对象.如
fun.call(window,args0,args1,.....);
fun.apply(window,[1,2,3]);
但要注意的是apply方法传递到函数内部的参数实际也是作为一个个参数传递的.如果在fun内部测试arguments.length的话,则长度为3.同样,我们可以采用arguments[0],arguments[1],arguments[2]来分别引用1,2,3三个参数,而不是用arguments[0][0],arguments[0][1],arguments[0][2]来引用3个参数.这样才能解释11行的代码.
posted @ 2008-04-30 17:11 zhangchao 阅读(2424) | 评论 (0)编辑 收藏
        Ext2.0中,Ext类有个namespace方法,该方法的作用是把传入的参数转换成对象.使用该方法的目的主要在于可以区分类名相同的类,这有点和java中的package作用类似.让我们先看下源码:
namespace : function(){
    
var a=arguments, o=null, i, j, d, rt;
    
for (i=0; i<a.length; ++i) {
        d
=a[i].split(".");
        rt 
= d[0];
            eval('
if (typeof ' + rt + ' == "undefined"){' + rt + ' = {};} o = ' + rt + ';');
        
for (j=1; j<d.length; ++j) {
            o[d[j]]
=o[d[j]] || {};
               o
=o[d[j]];
        }

    }

}
从代码可以看出,如果我们传入的字符串参数是以"."分割的,那么将会创建多个对象,比如:
Ext.namespace('system.corp');
则会创建2个对象,相当于执行了下面的代码:
system = {};
system.corp 
= {};
这样,我们在自定义类的时候就能这样使用:
Ext.namespace('system.corp');

system.corp.ManageCorp 
= function() {
    
//dosomething
}
如果还想定义一个同名的类,那么可以就使用不同的namespace来区分,这样2个类就不会冲突了:
Ext.namespace('system.admin');

system.admin.ManageCorp 
= function() {
    
//dosomething
}

此外,注意源码中"eval"方法的使用,如果有需要可以采用这种方式来解决问题.
posted @ 2008-03-19 22:24 zhangchao 阅读(1451) | 评论 (8)编辑 收藏
仅列出标题  下一页