2008年10月15日
昨日有媒体爆料10月20日微软将在中国再次对盗版WindowsXP进行打击，并首次对盗版Office进行验证，盗版软件用户将被采取黑屏等手段予以打击。但是仅仅几个小时之后，就有网友发帖称“10月20日未到，微软反盗xp黑屏补丁已被破解”。
从今日中午开始，网上各大论坛相继出现标题为“10月20日未到，微软反盗xp黑屏补丁已被破解”的网帖，网友警告微软称“想玩奉陪到底”，并在随后的帖子中给出了由一名为“f1098”的网友带来的破解方法：开始-运行-输入REGEDIT回车，在左边栏中找到HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsNT
CurrentVersionWinlogonNotifyWgaLogon项，将整个WgaLogon项删除即可。
上篇文章讲了 js 中的 传值和传址 和 函数的作用域 .
这章我们来探讨 js 中 的变量，表达式，和运算符 还有一些 js 语句。
升级中 ……
1, 表达式：
最简单的表达式：直接量或者变量名。 var a =1;
直接量表达式的值：本身。
变量表达式的值：该变量所存放或引用的值。
2 , 运算符：
一元运算符： 比如 - 3
二元运算符： 比如 3+4
三元运算符： 比如 ? :
新手常遇到的问题：
递增运算符：
比如：
i = 1 ;
j = ++ i ; // 前递增运算，即先对运算数进行递增，然后再去计算。
// 输出 i =2; j=2 ;
i = 1 ;
j = i ++; // 后递增运算，即先去计算，然后再对运算数进行递增。
// 输出 i =2; j=1 ;
3, 相等运算符：
= ： 赋值运算符；
== ： 相等运算符；
=== ： 等同运算符；
值 NaN 永远不会与任何值相等，包括自己。
alert(NaN == NaN); //false NaN 意思为 Not a Number
要检测一个值是否是 NaN, 可以使用全局函数 isNaN();
另外新手要注意：
var a =[1,2,3];
var b =[1,2,3];
document.write(a==b); // 输出 false .( 这个其实是 第一章讲的内容。 )
// 虽然值相同，类型相同，但址不同。
--------------------------------------------------------
var a =[1,2,3];
var b = a ;
var c = a ;
document.write(b===c);// 输出 true;
--------------------------------------------------------
var a = "1";
var b = true ;
document.write(a==b); // 输出 true
document.write(a===b); // 输出 false ； 值相同， 类型不同
4, 比较运算符：
要注意的就是字符串是进行琢个比较。
而且会区分大小写。
如果你的需求是不区分大小写：
可以使用 String.toLowerCase() // 纯小写
String.toUpperCase() // 纯大写 转换后 ，然后再去比较 .
5, in 运算符：
要注意的是：左边的值是其右边对象的属性。
比如：
var a = { x : 1 , y : 2 };
var b = “x” in a ; // true
var c = “toString” in a ; // true . 左边的值是其右边对象的属性。
6 instanceof 运算符：
要注意的是：左边的运算数是一个对象，右边的运算数是对象类的名字。
比如：
var a = new Date()
a instanceof Date; // true
a instanceof Object ; // true
a instanceof Number ; // false
7, 3 元条件运算符：
要注意的是：第一个运算数必须是一个布尔值。
X > 0 ? 3 : 2 ;
8, typeof 运算符：
要注意的是：由于 typeof 对所有的对象和数组都是返回 object;
所以它只能区分对象和原始数据类型时才有用。
要区别一种对象类型和另一种对象类型，可以使用 instanceof 和 constructor 属性。
9, delete 运算符：
要注意的是：并不是所有的属性和变量都能删除。
比如：
用 var 语句声明的变量不能被删除。
另外 ; 当 delete 删除一个不存在的属性时，返回 true ；（ ^_^ ，这个比较搞笑。）
var a = 1;
alert( delete a ); // 返回 false
alert( delete a.x ); // 返回 true
还有一个应该注意：
Delete 所能影响的只是属性值，并不能影响被这些属性引用的对象。
比如：
var my =new Object();
my.height = new Date();
my.width = my.height;
delete my.height ;
document.write(my.width);// my.width 仍然是引用 Date 对象
10,void 运算符：
void 的一个用途： 专门生成 undefined 值、
alert( void(0) )
alert( void(1) ) // 都输出 undefined
这里的 undefined 实际是 void() 运算后的 值 。
考虑到向后兼容性，用表达式 void 0 比使用 undefined 属性更有用 .
11, 异常处理：
抛出异常： throw
捕捉异常： try / catch / finally
If(x>0)
throw new Error(“x must not be negative!”);
try{
}
catch(e){
}
finally{ // 总是被最后执行 。通常进行 消除操作。
}
12,with 语句：
var form = frame[1].document.forms[0];
form.name.value = “ “;
form.address.value =” “;
这样可以使用 with 语句代替 ;
比如：
with(frame[1].document.forms[0]) ｛
name.value = “ “;
address.value =” “;
｝
当然书上强烈不推荐使用 with ， 呵呵。效率低，问题多多。
总结：
主要介绍了 js 中的变量，表达式，和运算符 还有一些 js 语句。
如果还有不懂，可以 google 搜索资料 . ( 学会使用搜索，你也就很厉害了。 )
转眼间，学了 3 章了， 不知道大家感觉如何。
将就些吧，学习最重要的还是靠自己，不懂或者有疑问的地方马上 写例子测试，验证。或者查资料。 这样可能印象会更深入些。
加油 …….
上篇文章讲了 js 中的一些概念（词法结构） 和 数据类型（部分）。
这章我们 继续 . 然后了解下 js 中操作数据 和 函数的 作用域。
1, 对象跟基本类型之间的转换：
不管何时，只是对象非空，在布尔环境中都为 true.
如 ;
new Boolean(false);
new Number(0);
new String(“”);
new Array();
上面虽然内部值是 false, 但对象的值是 true;
Object à valueOf() à toString()
其中 Date 类，是先执行 toString() 转换。
2,js 中操作一个数据值：
任何语言都有自己的操作数据的方法；
Js 也不例外， js 有 3 种重要的方式来操作一个数据值。
1) 复制它。例如把它赋给一个新的变量。
2) 把它作为参数传递给一个函数或方法。
3) 可以和其他值比较大小。
Js 通过传值和传址 2 种方式操作这些数据的值。
从名称可以看处，传值 是通过传递值来操作数据。在赋值的过程中，对实际的值进行了拷贝，存储到一个新的变量中。拷贝的值和原来的值是 2 份完全独立的值。所以如果你改变了拷贝的值，并不会影响原来的值。当比较大小时候，通常进行琢个字节比较。
传址 从名字来看，就是通过传递地址来操作数据。在赋值的过程中，对实际的值的地址（可以说是引用）进行了拷贝，他们不是完全的独立，所以如果你通过引用改变了值，那么原始的值也会改变。当比较大小的时候，通常是看他们是否引用同一个地址来比较。
简单的传址例子：
var a = new Date();
alert(a.getDate());
var b = a ;
b.setDate(21);
alert(a.getDate()) // 输出 21
3, 一般来说：
基本数据类型通过传值来操作的。（如果忘记了哪些是基本数据类型，可以往回看。）
对象数据类型通过传址来操作的。（比如 数组和函数）
例子：
<script>
// 传值
a=1;
b=a;
b=2;
alert(a); // 输出 1
// 传址
x=[1,2];
y=x; // 赋给 y 的只是 x 的一个引用，而不是 x 本身。数组已经在语句中被赋值了，执行过这段代码后，仍旧只有一个数组对象，只不过我们有 2 个对他的引用了。
y[0]=2;
alert(x[0] +" | " +x[1]); // 输出 2 | 2
</script>
其中我们必须注意字符串：
js 中字符串是通过传址来复制和传递的，而他们是通过传值来比较的。
对象和数组是用传值来传递的，只不过传递的这个值实际是一个引用，而不是对象本身。
总结 :
|
类型
|
复制
|
传递
|
比较
|
|
数字
|
传值
|
传值
|
传值
|
|
布尔
|
传值
|
传值
|
传值
|
|
字符串
|
不可变
|
不可变
|
传值
|
|
对象
|
传址
|
传址
|
传址
|
不可变：在 JS 中，没有方法去改变字符串值的内容。
对字符串来说，传值还是传址，意义不大。
4, 垃圾收集机制：
Js 中自动释放内存。
比如：
var s =”heelo”;
var b = s.toUpperCase();
s=b; // 运行到这里后， js 会自动检测不再使用某个对象，因为 s=b 了，所以 js 会自动释放字符串“ heelo ”所占的存储空间。即我们不能再获取原始的 “heelo” 值； .
5 , javascript 变量：
Js 是非类型的。它的变量可以放任何类型的值。
变量的声明：
var a ;
var b ;
或者
var a , b ;
或者
var a=0 , b=1 ;
重复声明 是合法的，
如果 遗漏声明 , js 会隐式的声明该变量。当然隐式声明的变量总是全局变量。
6 , 变量的作用域：
Js 有 2 种：全局和局部。
从名字的定义可以知道，全局变量的作用域是全局性的。
在 js 代码中，处处都有定义。
局部变量的作用域是局部的。
在函数体内定义。
同名的局部变量的优先级比同名的全局变量高，下面的例子说明了这点：
var a ="abc"; // 全局变量
function check(){
var a = "efg"; // 同名的局部变量
document.write(a);
}
check(); // 输出 efg
看一个比较经典的例子 :
var scope = "global";
function f(){
alert(scope); // 输出 undefined
var scope = "local";
alert(scope); // 输出 local
}
f();
为什么第一个会输出 undefined 呢？
因为 js 规定当 局部变量和全局变量的名称相同的时候，函数体内的同名全局变量会被隐藏。
那么刚才例子 实际 等价于：
function f(){
var scope;
alert(scope);
scope = "local";
alert(scope);
}
f();
OK ，如果你看懂了这个例子，说明你对局部和全局的一些区别稍微了解了。
7 , 变量的作用域：
从里到外：
|
词法作用域
|
作用域链
|
变量查找
|
|
var x = 1;
function f(){
var y =2 ;
function g(){
var z =3 ;
}
}
|
调用 g() 对象 ; z =3 ;
调用 f() 对象 ; y =2 ;
全局变量 x = 1
|
在此定义了吗？
是
否
获得值
在此定义了吗？
是
否
获得值
在此定义了吗？
是
否
获得值
未定义
|
8 , 客户端全局变量：
在客户端 js 中， Window 对象代表浏览器窗口，他是一个全局对象。、
比如 ; 我们常用的 parseInt() , Math() 都是 Window 对象定义的属性。
Js 允许多个全局变量的执行环境，每个环境有不同的全局对象。
比如：客户端 js 的每个独立的浏览器窗口，或者同一窗口的不同帧。
其中的代码都运行在自己的执行环境中，具有自己的全局对象。
当然可以使用 表达式 parent.frames[0].x ; 来引用第一个帧中的全局变量 x ; 这样就把不同帧中的代码联系起来了。
不过这里有安全性问题。
总结 ;
主要讲了 传值和传址 和 函数的作用域 。
以前没彻彻底底的看过js相关的学习资料，觉得很有必要再看看基础的东西。一起来学习。
1 , javascript字符集：
javascript 采用的是 Unicode 字符集编码。
为什么要采用这个编码呢？
原因很简单， 16 位的 Unicode 编码可以表示地球人的任何书面语言。这是语言 国际化的一个重要特征。 ( 大家也许见过用中文写脚本，比如： function 我的函数 () {} );
Javascript 中每个字符都是用 2 个字节表示的。（因为是 16 位编码）
2 , 大小写敏感：
js 是一种区分大小写的语言。
注意下：以前我也犯过的错误。
HTML 是不区分大小写的。经常看见有人这么写 ,
<input type=”button” onClick=”a()” /> （这样写是对的）
如果放到 JS 中，就必须使用 onclick （小写哦！）
同时 XHTML 中也只能使用小写。
这个我们并不需要太关心，象这种问题，其实都可以自己给自己定一个标准，自己写程序的时候全部小写。
另外每行程序后 分号 也是一样，我们都写上。
3 , 注释：
单行：
// 注释 1
/* 注释 2 */
多行：
/* 注释 3
* 注释 3
* 注释 3
*/
4 , 标识符：
标识符就是一个名字，用来命名变量和函数。
规则：第一个字母必须是字母，下划线 (_) ，或美圆符号 ($) 。
为什么第一个字母不能为数字？
如果第一个为数字， js 很容易就把它当作数字处理了，那么命名就没意义了， js 规定了后，就很容易的区分了标识符和数字了。
5 , 直接量：
就是程序中直接显示出来的数据值。
比如： 12 , 1.2 , “ hello “ , true , null , [1,2,3,4]
这些都是直接量。
6 , 保留字和关键字：
具体是哪些，可以去 google.cn 。
其实我们只要不取一些特郁闷的名字，都不会冲突的。
7 ,js 数据类型：
3 种基本的类型；数字，字符串和布尔值。
2 种小数据类型： null 和 undefined . ( 为什么叫小数据类型？因为他们只定义了一个值 )
1 种复合类型： object. ( 在这个类型中，它的值可以是基本数据类型，也可以是复合类型，比如其他的 object. )
注意：在对象中有一个特殊的对象 ----function.( 它是一个可以执行代码的对象 .)
其他的一些对象 :
数组：
Date 类 ： 是日期的对象。
RegExp 类： 正则表达式的对象。
Error 类： js 中发生错误的对象。
8 , 使用数据类型注意的地方：
1): 数字：
由于数字有什么 8 进制， 10 进制， 16 进制等。。。
八进制： var num = 011; // 以 "0" 开头
十六进制： var num =0x1f; // 以 "0x" 开头
所以对于 js 这个都能识别的语言来说，就必须得注意。
alert(377); // 377
alert(0377); //255 = 3 * 64 + 7 * 8 + 7 * 1
进行算术运算有个重要的对象： Math.
具体可以去网上下载手册，查询里面的方法。
2 个有用的函数： isNaN() 和 isFinite()
isNaN() : 用于检查其参数是否是非数字值。 // 提示：是非数字哦。 (not a number)
document.write( isNaN (0) ) // 返回 false
document.write( isNaN (5-2) ) // 返回 false
document.write( isNaN ("Hello") ) // 返回 true
isFinite(number) 函数用于检查其参数是否是无穷大。
如果 number 是有限的，则返回 true. 如果 number 是 NaN( 非数字 ) 或者是无穷大，则返回 false;
2): 字符：
‘you’re right’;
这样写的话 js 会误以为 在 you 字母后就结束了，引起错误。
所以当遇到这种情况的时候，必须用到转义。
我们可以这么写：
‘you"’re right’;
另外：你可以 google.com 搜索 转义序列表 。
字符串的简单操作例子：
var a = "cssrain";
var b = a.charAt(a.length-1); // 从字符串 a 中截取最后一个字符。 输出： n
var c = a.substring(0 , 2); // 从字符串 a 中截取第 1 ， 2 个字符。 输出： cs
var d = a.indexOf('s'); // 从字符串 a 中查找 第一个 s 出现的位置。 输出： 1
从例子可以看出，基数都是从 0 开始的。
var e = a.substring( a.length-1 ); // 可以看出， substring 第 2 个参数不写的话，
// 默认 是到最后。
var f = a.substring( a.length-1 , a.length);// 等价于
3): 数字跟字符之间的转换：
数字转字符：
var number_to_string = number + “ ”; // 方法 1 ：添加一个空的字符串。
var number_to_string =String(number); // 方法 2 ：使用 String() 函数。
var number_to_string =number. toString(); // 方法 3 ：使用 toString() 函数。
注： toString() 方法默认是以 10 进制转换。
如果要使用 8 进制转换可以 这么写： number. toString(8);
字符转数字：
var string_to_number = string – 0 ; // 方法 1 ： 字符串减去 0 。
var string_to_number = Number(string) ; // 方法 2 ：使用 Number () 函数。
var string_to_number = parseInt(string) ; // 方法 3 ：使用 parseInt () 函数。
方法 1 中不能 用 string+0 ; 这样会导致字符串拼接，而不是类型转换。
方法 2 中的 Number 函数转换，比较严格。
比如：
var a = "19cssrain86";
var b = Number(a); // 输出 NaN.
如果我们使用方法 3 。
var c = parseInt(a); // 输出 19
可以看出 parseInt() 会自动忽略非数字的部分。
parseInt() 只取整数部分，忽略小数部分。
parseFloat() 会把小数部分也取到。
和 toString() 一样， parseInt 也有进制，默认是 10 进制。
如果想使用 8 进制，可以这么写： parseInt( “077” , 8 ); // 输出 63 = 7 * 8 + 7
当字符以 0 开头的时候，我们必须把 第二个参数 指明，不然 js 可能会以 8 进制去转换。
4): 布尔类型：
布尔在数字环境中： true 转换为 1 ， false 转换为 0 。
在字符环境中： true 转换为 “true” ， false 转换为 “false” 。
布尔转换：
var x_to_Boolean = Boolean(x); // 方法 1 ：使用 Boolean () 函数。
var x_to_Boolean = !x; // 方法 2 ：使用 感叹号。
5): 函数的定义：
方法 1 ：普通定义
function square(x){
return x*x;
}
方法 2 ：函数直接量定义
var square = function(x){ return x*x; } // 推荐使用
方法 3 ：构造参数
var square = new Function(“x”,”return x*x;”); // 效率低
6): 对象：
如果有一个名为 cssrain 的对象 ， 他有一个高度 height 的属性。
那么我们可以这么引用：
cssrain.height;
还可以使用关联数组定义： cssrain[“height”];
创建对象：
方法 1 ：
var point = new Object();
point.x = 3;
point.y = 5;
方法 2 ：使用对象直接量
var point = {x:3 , y:5 }
当然 json 也可以咯。
对象在字符的环境下，会调用 toString() 方法。
数字环境下，会调用 valueOf() 方法。
布尔环境下，非空对象为 true;
7): 数组：
常规数组：以非负整数做为下标。 image[0]
关联数组：以字符做为下标。如： image[“width”]
js 不支持多维数组，但数组里面可以嵌套数组。
创建数组：
方法 1 ：
var a = new Array();
a[0] = “1”;
a[1] = 2;
a[2] = { x:1, y:3};
方法 2 ：
var a = new Array(“1” , 2 , {x:1,y:3} );
注意下：如果只传了一个参数；比如 var a = new Array(3);
那么它是表示： 3 个未定义元素 的 新数组。
方法 3 ：使用数组直接量
var a =[“1” , 2 , {x:1 , y :3 }]; // 注意外面的 括号 ， 不是花 括号。
8):null 和 undefined ：
null 表示无值；
undefined : 使用一个并未声明的变量，或者使用了已经声明的变量但未赋值或者使用了一个并不存在的属性。
undefined==null
如果要区分：
可以使用 === 或者 typeof 运算符。
9 , 新手常遇到的疑惑：
var s =”you are right”;
var b = s.substring(s.lastIndexOf(“ ”)-1 , s.length);
疑惑： s 是对象还是字符串，为什么字符串会有方法呢？
回答： s 是字符串。之所以有方法 ，是因为 string 类型 有一个相应的对象类（ String ）。
同样数字和布尔都有相应的 Number , Boolean 类。
Js 会内部进行相应的包装对象。 String 对象就替换了原始的字符串。
总结：
简单了介绍了 js 中的一些概念（词法结构） 和 数据类型（部分）。
好了，今天就说到这里， 明天我们 继续。 ^_^ 。
一、包含语句<%@include file="uri" %>
可包含的文件可以是任何后缀的文件如，*.inc、*.htm、*.jsp、*.txt等。例如，%@include file="hello.inc"%、<%@include file="bottom.jsp"%>。
注：include指令包含的是文件的内容，所以被包含文件中不能包含有<html><head><body>三个标签。
二、另一个包含语句<jsp:include page="uri"/>
用法主要有三种：
<jsp:include page="url"/>
<jsp:include page="url" flush="true"/>
<jsp:include page="url" flush="true">
<jsp:parameter name="name" value="value"/>
</jsp:include>
三、比较两种包含语句的不同
1、后者又叫标签指令形式。和html有些类似，必须要有</jsp:XXX>结束或是/>结束。
2、后者，可以向被包含页传递参数。当需要向被包含页传递参数时，被包含页必须是jsp动态页面。
3、接收包含语名的方法还是 request.getParameter("参数名");
4、后者如果包含的页面是jsp文件，而自动处理，如果包含的是静态内容，则直接包含进来。
四、学到这里的时候可能经常有些面试题：请问jsp中两种包含语句的区别？
1、理解一：
<%@include file="uri"%>，静态包含，不管被包含页面的内容如何，先包含时行一起执行后发送到客户端。
<jsp:include page="uri"/>，动态包含，能自动区分被包含文件是静态还是动态的。执行时，如果是静太资源则和上面一样把内容加进来，如果是动态资源，则先各自处理之后将处理后的结果包含在一起。