//2005中ctrl+J 有可能出提示
//文本编辑出注释的快捷键
名词解释：
{
//Java: 爪哇语言, 在因特网世界范围的 web 网页运转的以网络为基础的编程语言 (计算机用语)
//script : 手稿, 剧本, 手迹
//cs结构： 客户端应用程序，用户需要下载客户端，例如QQ
//BS结构： 浏览器应用程序，具有远程服务器，例如网页
脚本语言：解释性语言，不进行编译，只在运行至相应代码时进行解释
}
完整的Javascript组成
{
核心：ECMAscript
文档对象模型：DOM Object Model*/
浏览器对象模型：BOM Object Model*/
}
Javascript作用
{
提供用户交互
动态更改内容
数据验证
}
//建站：文件→新建→网站→ASP.NET 网站→位置（文件系统）→语言（Visual C#）→路径（添加合适路径储存网页）
//添加HTML网页：（在资源管理器）添加新项→HTML页→起名→确定
//自动生成的HTML中第一行（）表示生成文档类型
//添加script标签：
{
位置：可以添加在任何位置，但是一般添加在
格式：
类型：
{
内嵌脚本： 放在标签中并且有Javascript文本
例子：
↑
文本类型
外挂脚本（建议使用）： 放在标签中，没有方法体，只有地址
例子：
↑
地址 扩展名：.js
添加→添加新项→Jscript文件→起名→添加
Jscript文件中的内容：document.write("能看见呢？");
}
}
//方法
{
document: document.write("这是我的第一个Js文本")
声明变量： var
例子：var number=55;
强制转换类型：
{
parseFloat(ppp) !注意：parseFloat的拼写和大小写，如果在页面加载时出现错误则程序不向下运行!
Boolean()强制转换,当参数为空字符串和null时，得到false ：例子: document.write(Boolean(100)+"
");
var color="violet";
document.write(color.length,"
");
var num=10;
document.write("10的二进制数为",num.toString(2),"
"); 10的二进制数为1010
document.write("10的八进制数为",num.toString(8),"
"); 10的八进制数为12
document.write("10的十进制数为",num.toString(10),"
"); 10的十进制数为10
document.write(Number(testFunction())+"
"); NaN
document.write(Number("123.12")+"
"); 123.12
document.write(Number(false)+"
"); 0
document.write(Number(true)+"
"); 1
document.write(parseInt("10")+"
"); 10
document.write(parseInt("56.6")+"
"); 56
var str="marssion";
document.write(typeof(str)+"
"); 显示：string
var temp;
document.write(typeof(temp)+"
"); 显示：undefined
var myObject={x:0,y:0};
document.write(typeof(myObject)+"
"); 显示： object
document.write(typeof(null)+"
"); 显示： object
var oTemp;
document.write((oTemp==undefined)+"
"); 显示： true
function testFunction(){} //如果函数没有实现则返回undefined值
document.write((testFunction()==undefined)+"
"); 显示：true
document.write((null==undefined)+"
"); 显示： true
}
}
//调用函数
{
function a(Sname,Smessage)
{
return Sname+Smessage;
}
var b=a("William","Welcome");
document.write(b);
}
//if语句
{
var num=10;
var num1="10";
if(num==num1)
{
document.write("相等");
}
if(num!=num1)
{
document.write("不相等");
}
}
//for语句
{
for(var a=1,b=0;a<101;a++)
{
b+=a;
}
document.write(b);
}
//while语句
{
var a=1;var b=0;
while(a<101)
{
b+=a;
a++;
}
document.write(b);
}
//do while 语句
{
var a=1;
var b=0;
do
{
b+=a;
a++;
}while(a<101);
document.write(b);
}
//alert 方法 和自定义属性 自定义object类型的变量 delete方法
{
var o=new Object();
o.name="hellow word";
alert(o.name); */
delete(o.name);
alert(o.name);
}
//全等运算符（===）
{
var sNum="55";
var tNum=55;
document.write(sNum==tNum,"
"); 显示： true
document.write(sNum===tNum,"
"); 显示： false
document.write(sNum!=tNum,"
"); 显示： false
document.write(sNum!==tNum,"
"); 显示： true
}
//switch
{
var date=new Date();
var time=date.getDay();
switch(time)
{
case 0:
document.write("星期日");
break;
case 1:
document.write("星期一");
break;
case 2:
document.write("星期二");
break;
case 3:
document.write("星期三");
break;
case 4:
document.write("星期四");
break;
case 5:
document.write("星期五");
break;
case 6:
document.write("星期六");
break;
}
}
↑↓←→
//arguments
{
function a(aa,bb,cc)
{
if(arguments.length==1)
{
document.write(aa+"
");
}
else if(arguments.length==2)
{
document.write(aa+"~~~~~"+bb+"
");
}
else if(arguments.length==3)
{
document.write(aa+" "+bb+" "+cc+"
");
}
}
a("william"); 显示：william
a("william","welcome"); 显示：william~~~~~welcome
a("william","welcome","myhouse"); 显示：william welcome myhouse
}
//with
{
var sMessage="hello world";
with(sMessage)
{
document.write(toUpperCase(),"
"); 显示：HELLO WORLD
document.write(length,"
"); 显示：11
}
}
//void用法
{
单击一下下
}
//for in 用法
{
var o=new Object();
o.name="nameshuxing";
o.age=21;
o.gender="nan";
随便起的变量
↓
for(sss in o)
{
document.write(o[sss],"
"); “对象[属性名字]”显示的是相应属性的内容，就像hashtable中的查询一样*/
}
document.write("window对象属性
");
for(aaa in document)
{
document.write(aaa,",
");
}
}
//闭包
{
function test(num1,num2)
{
var num3=10;
function inter(num4)
{
return num1+num2+num3+num4
}
return inter;
}
var zhi=test(10,20);
document.write(zhi(20));
var aa="hello world";
function a()
{
document.write(aa,"
");
}
a();
}
JS高级编程 第二章 对象 ↑↓←→
//火狐浏览器能当计算器，输入“javascript:3-2”显示1，也可以写一些简单的Js语句，函数什么的
//Javascript在什么时间被执行
{
1、在文档被装载的时候
2、文档加载后
3、被其他的Javascript语句调用
以下取自ajax and dot。Net2.0
脚本装载周期：
当网页被浏览器加载时，javascript在以下3个时间点被执行
一：在文档被装载期间
注意：此时文档还没有被加载，文档中的元素不能被使用。
During load script execution
alert has executed!
二：文档加载后
在文档被加载后， 标记 onload() 事件发生，此时文档已经加载完毕。
After load script execution
Final line...almost done!
三：被其他的javascript语句调用
}
//对象的官方概念 :ECMA-262把对象定义为“属性的无序集合，每个属性存放一个原始值、对象或函数。”这意味着对象是无特定顺序的值的数组。
//Javascript对象分类
{
1、本地对象 例如：ECAM-262定义的对象：Object Functioin、Boolean、 Number 等
2、内置对象 例如：Global对象、Math对象
3、宿主对象 例如：所有DOM、BOM对象
}
//对象的创建
{
使用new关键字创建本地对象
例如：var o=new Object();
var car = new Object();
car.name = "凯迪拉克";
car.money = 1111111;
document.write("我新买的" + car.name + "
"); 显示： 我新买的凯迪拉克
document.write("这破车花了我" + car.money + "
"); 显示：这破车花了我1111111
使用对象直接量创建
例如：var oo={};
var ooo={x:1,y:2};
var obj = { x: 1, y: 2 }
for (mycar in obj) { /用对象直接量创建相当于创建一个函数（函数体内包含X Y（做成未赋值的属性））并用一个值初始化它并把属性赋值/
document.write(mycar + "
");
}
for (aaa in obj) {
document.write(obj[aaa]+"
");
}
x
y
1
2
}
//对象的属性的表示方法
{
1、object.property
2、object["property"]
var car={x:1};
car["color"]="黑色";
car["name"]="宝马";
car["price"] = 150000;
var msg;
for(msg in car) //调用方法显示出car中的所有属性的名称
{
msg+=" ";
document.write(msg);
}
x color name price
}
//Javascript本地对象
{
Object 类
{
属性
Constructor——对创建对象的函数的引用（指针）。对于Object类，该指针指向原始的object()函数(每个对象都有这个属性，它指向用来初始化该对象的构造函数)
Prototype——对该对象的对象原型的引用。对于所有的类，它默认返回Object对象的一个实例。
}
Number 类
{
创建：numObj=new Number(value)
属性
MAX_VALUE 属性|MIN_VALUE 属性|NaN 属性|NEGATIVE_INFINITY 属性|POSITIVE_INFINITY 属性|constructor 属性|prototype 属性
方法
toString 方法|valueOf 方法
{
var num1 = mynumber.valueOf();
var num2 = mynumber.toString();
document.write(num1, "
"); valueOf()和toString()在用法和结果上没什么区别
document.write(num2,"
");
}
toFixed(int值)方法
{
var mynumber = new Number(100);
var num2 = mynumber.toFixed(4);
document.write(num2, "
");
}
Number.MAX_VALUE方法和Number.MIN_VALUE方法
{
var max = Number.MAX_VALUE;
var min = Number.MIN_VALUE;
document.write(max+"
");
document.write(min);
1.7976931348623157e+308
5e-324
}
}
String类
{
语法：
indexOf(“查找的子字符串”，查找的起始位置)
返回子字符串所在的位置，如果没找到，返回 －1
例如：
var x
var y=“abcdefg”;
x=y.indexOf(“c” , 0 );
//返回结果为2，起始位置是0
var str = new String("hello world 字符串示例");
//Lenght属性
document.write(str.length, "③
");//获取字符串的长度
//charAt charCodeAt()
document.write(str.charAt(0), "④
");//获取指定位上的字符
document.write(str.charCodeAt(0), "
"); //获取指定位上的字符的ascii码
//concat() 与“+”号相同
var oStringObject = new String("hello ");
var sResult = oStringObject.concat("world");
document.write(sResult, "⑤
");
document.write(oStringObject, "⑥
"); //没有改变本身的值
//indexOf() lastIndexOf()
var myStr = new String("hello world");
document.write(myStr.indexOf("o"), "⑦
"); //下标从0开始第一个“o”在下标4的位置上
document.write(myStr.lastIndexOf("o"), "⑧
");//获取最后一个指定字符的位置 //下标从0开始从后数第一个“o”在下标7的位置上
//slice() substring() //字符串的截取，两者不同的是“slice()”的（）中可以放负数，“substing()”的（）中如果放入负数则被系统看成0
document.write(myStr.slice(3), "⑨
"); //第一个参数表示的从3开始截（包括3）没有第二个参数就有多长截多长
document.write(myStr.substring(3), "⑩
"); //第一个参数表示的从3开始截（包括3）没有第二个参数就有多长截多长
document.write(myStr.slice(3, 7), " 11
"); //第一个参数表示的从3开始截（包括3）第二个参数表示截到下标7为止（不包括7）
document.write(myStr.substring(3, 7), " 12
"); //同上
document.write(myStr.slice(-3), " 13
");//相当于slice（8） 字符串长度+参数 //可以接受负数，-3表示截取字符串中的最后3个
document.write(myStr.substring(-3), " 14
");//负数相当于0 //不能接受负数，系统自动转换成0，表示从0开始截，有多长截多长
document.write(myStr.slice(3, -4), " 15
");//相当于slice（3，7）
document.write(myStr.substring(3, -4), " 16
");//相当于substring（0，3）较小的数字放在第一个参数，位置自动转化
//toLowerCase() toUpperCase() toLocaleLowerCase() toLocaleUpperCase() //转换大小写，toLocaleLowerCase() toLocaleUpperCase()是基于特定的区域实现的（一般用不上）
document.write(myStr.toLowerCase(), " 17
");
document.write(myStr.toLocaleLowerCase(), " 18
");
document.write(myStr.toUpperCase(), " 19
");
document.write(myStr.toLocaleUpperCase(), " 20
");
//big() small()
document.write(str.small()," 21
");//缩小字体
document.write(str.big()," 22
");//放大字体
//斜体字和删除线
var ss=str.italics()+str.strike(); //italics()方法是将字体显示为斜体， strike()方法是在显示的字体上加上删除线
document.write(ss);
fontcolor();设定字体颜色
var a = "换个字体颜色";
a = a.fontcolor("red");
document.write(a);
sub();把字变成下标
document.write("H"+"2".sub()+"O"); //这是字符串的方法，如果用var b = 2; b = b.sub();则行不通。
}
Math类
{
//2秒自动刷新
var test=Math.E;//表示自然对数的底
document.write(test,"
");
test=Math.PI;
document.write(test,"
");
document.write("2秒自动刷新，随机显示图片");
var i = 0; //Math.random( ) ：产生0－1的随机小数,Math.random()*10产生一个0-10的随机小数
i=Math.round(Math.random()*10); //Math.round( )：四舍五入取整，如9.34 取整为9
document.write("");
}
Date类
{
var 日期对象 = new Date (年、月、日等参数)
例：
var mydate=new Date( “July 29, 1998,10:30:00 ”)
如果没有参数，表示当前日期和时间
例：
var today = new Date( )
方法
{
getYear(): 返回年数 getMonth():返回当月号数 getDate(): 返回当日号数 getDay():返回星期几 getHours():返回小时数 getMintes():返回分钟数 getSeconds():返回秒数 getTime() : 返回毫秒数
setYear():设置年 setDate():设置当月号数 setMonth():设置当月份数 setHours():设置小时数 setMintes():设置分钟数 setSeconds():设置秒数 setTime ():设置毫秒数
}
//第一种参数
var someDate=new Date(2008,05,20,12,00,00);
document.write(someDate,"
");
//第二种参数
someDate=new Date("july 20 2008 12:30:30");
document.write(someDate,"
");
//获取系统当前日期
var today=new Date();
document.write(today,"
");
document.write("某特定时间的星期为"+today.getDay()+"
");//0代表星期日
document.write("某特定时间的日子为"+today.getDate()+"
");
document.write("某特定时间的月份为"+(today.getMonth()+1)+"
");//月从0月开始 0代表十二月，0~11
document.write("某特定时间的年份为"+today.getFullYear()+"
");
document.write("某特定时间的小时为"+today.getHours()+"
");
document.write("某特定时间的分钟为"+today.getMinutes()+"
");
document.write("某特定时间的秒为"+today.getSeconds()+"
");
//通过setDate方法修改日期，其他类似
today.setDate(25);
document.write("修改后的日期为"+today.getDate()+"
");
Fri Jun 20 12:00:00 UTC+0800 2008
Sun Jul 20 12:30:30 UTC+0800 2008
Wed Aug 30 17:43:14 UTC+0800 2006
某特定时间的星期为3
某特定时间的日子为30
某特定时间的月份为8
某特定时间的年份为2006
某特定时间的小时为17
某特定时间的分钟为43
某特定时间的秒为14
修改后的日期为25
var now = new Date();
var hour = now.getHours();
if (hour >= 0 && hour <= 12)
document.write("上午好!")
if (hour > 12 && hour <= 18)
document.write("下午好!");
if (hour > 18 && hour < 24)
document.write("晚上好!");
document.write("
今天日期:" + now.getYear() + "年"
+ (now.getMonth() + 1) + "月" + now.getDate() + "日"); //月份数字0－11，注意＋1
document.write("
现在时间:" + now.getHours() + "点" + now.getMinutes() + "分" + now.getSeconds() + "秒");
下午好!
今天日期:2006年8月30日
现在时间:17点58分22秒
//setTimeout() 的用法
{
setTimeout（“调用的函数”,”定时的时间”）
例：
var myTime＝setTimeout（”disptime( )”,1000）; //设定定时器
clearTimeout（myTime）; //解除定时器
}
setInterval() 用法同上
}
}
↑↓←→
//数组
{
声明数组三种方式
第一种 var 数组名 = new Array();
例： var emp = new Array()
第二种 var 数组名=new Array(5,4,3,2,1,”test”);
第三种 var misc = [ 1.1, true, "a", ];
var b = [[1,{x:1, y:2}], [2, {x:3, y:4}]];
function Circle(x,y,z)
{
this.x=x;
this.y=y;
this.z=z;
}
var c=new Circle(1,2,3);
c[0]="this is an element";
c[1]="this is an element";
c[2]="this is an element";
for(var temp in c)
{
document.write(c[temp],"
"); //显示：1,2,3,this is an element,this is an element,this is an element
}
var test=new Array(1,2,3,4,5);
for(var i=0;i
document.write(test[i],"
");
}
document.write("改变length的值前数组的长度：" + test.length, "
");
test.length=3;
document.write(test, "
");
document.write("改变length的值后数组的长度：" + test.length, "
");
delete test[0];
document.write(test, "
");
document.write("使用delete后数组的长度：" + test.length);
1
2
3
4
5
改变length的值前数组的长度：5
1,2,3
改变length的值后数组的长度：3
,2,3
使用delete后数组的长度：3
Javascript并不支持真正的多维数组，但是它允许使用元素为数组
var table=new Array(3);//3行
for(var i=0;i
table[i]=new Array(3);//每行3列
}
for(var row=0;row
for(var col=0;col
table[row][col]=row*col;
}
}
for(var r=0;r
for(var c=0;c
document.write(table[r][c]+" ");
}
document.write("
");
}
0 0 0
0 1 2
0 2 4
//数组的方法
{
join()方法 ： 该方法可以把一个数组的所有元素有转换成字符串，然后再把他们连接起来
var test=[1,2,3];
var s = test.join("-");
document.write(test, "
");
document.write(s, "
");
1,2,3
1-2-3
reverse()方法 : 该方法将颠倒数组元素的顺序并返回颠倒后的数组
var test=[1,2,3,4,5,6];
test.reverse();
for (var i = 0; i < test.length; i++)
{
document.write(test[i], "
");
}
6
5
4
3
2
1
sort()方法 ： 该方法在原数组上对数组元素进行排序
var fruits=["manago","orange","apple","strawberry"];//在元数组上进行排序
var myFruits=fruits.sort();
for(var i=0;i
document.write(myFruits[i],"
");
}
for (var i = 0; i < fruits.length; i++) {
document.write(fruits[i], "
");
}
var test=[33,4,611,222];
test.sort();
for(var i=0;i
ocument.write(test[i],"
");
}
test.sort(function(a,b){return a-b;});
for(var i=0;i
document.write(test[i],"
");
}
apple
manago
orange
strawberry
apple
manago
orange
strawberry
222
33
4
611
4
33
222
611
concat()方法 ： 该方法能创建并返回一个数组
var test=[1,2,3];
document.write(test,"
");
result = test.concat([8, 9]);
for(var i=0;i
document.write(result[i],"
");
}
1,2,3
1
2
3
8
9
slice()方法 ： 返回的是指定数组的子数组
var test=[1,2,3,4,5,6];
var result=test.slice(0,3);
for(var i=0;i
document.write(result[i],"
");
}
1
2
3
splice()方法 ： 该方法可以把元素从数组中删除，也可以将新元素插入到数组中，它在原数组上修改数组，并不创建新数组
!只在firefox中能正确浏览! 注意：和concat()不同，splice()并不将它插入的数组参数展开，也就是说，如果传入的是一个数组插入的就是一个数组而不是这个数组的元素
//IE浏览器无效，使用FireFox
var test=[1,2,3,4,5,6,7,8];
//删除元素
var result = test.splice(4); //没有指定第二个参数表示从起始位置删至结尾，删除了5，6，7，8，将删除的数组返回
for(var i=0;i
document.write(result[i],"
");
}
document.write("---------------------------
");
for(var i=0;i
document.write(test[i],"
");
}
//添加元素
document.write("---------------------------
");
var test1=[1,2,3,4,5,6,7,8];
//第二个参数表示要删除的元素数，0表示不删除，直接插入，非0表示删掉之后再插入
var addResult=test1.splice(2,4,"liwei","marssion");
for(var i=0;i{
document.write(addResult[i],"
");
}
document.write("---------------------------
");
for(var i=0;i
document.write(test1[i],"
");
}
5
6
7
8
---------------------------
1
2
3
4
---------------------------
3
4
5
6
---------------------------
1
2
liwei
marssion
7
8
push()方法和pop()方法 //方法可以将一个或多个新元素附加到数组的尾部，然后返回数组的新长度，方法pop()将删除数组的最后的一个元素，减少数组的长度，返回它删除的值。
//注意：这两个方法都是在原数组上修改数组，而非生成一个修改过的数组副本，联合使用push()和pop()，就可以用javascript实现一个先进后出的栈；
var temp=[];
document.write("Push
");
temp.push(1, 2, 3, 4);
document.write("数组元素有："+temp+"
数组长度是："+temp.length);
document.write("
");
document.write("Pop
");
temp.pop();
document.write("数组元素有："+temp+"
数组长度是："+temp.length);
Push
数组元素有：1,2,3,4
数组长度是：4
Pop
数组元素有：1,2,3
数组长度是：3
unshift()方法和shift()方法 //方法unshift()会将一个或多个元素添加到数组的头部，然后把已有的元素移动到下标较大的位置以腾出空间，它返回的是数组的新长度；
//方法shift()会删除并返回数组的第一个元素，然后将后面的所有元素都向前移动以填补第一个元素留下的空白
//先进先出（FIFO）
var test=[];
document.write("Unshift
");
test.unshift(1, 2, 3, 4);
document.write(test,"
");
document.write("Shift
");
test.shift();
document.write(test,"
");
Unshift
1,2,3,4
Shift
2,3,4
instanceof运算符与typeof运算符相似，用于识别正在处理的对象的类型，不同的是，instanceof方法要求开发者明确地确定对象为某特定类型
例：var ostring=new String(“hello”)
document.write(ostring instanceof String); //返回一个boolean值，类型正确返回true否则返回false
}
}
//对象的共同属性和方法
{
toString() //object类的方法，将非字符串转换成字符串
toLocaleString() //object类的方法，返回对象本地化字符串，object默认的方法自身不做任何局部化，返回结果与toString()相同
hasOwnProperty(property) //object类的方法，判断对象是否有某个非继承属性
propertyIsEnumerable(property) //object类的方法，属性（非继承）是否可用 For in枚举
isPropertyOf(object) //object类的方法，判断该对象是否为传入对象的原型
}
JS高级编程 第三章： Function 函数、类、构造函数、原型 Classes,Constructors,and Prototypes ↑↓←→
//JS的断点： 在需要打断点的地方写上debugger ， 在遇到版本不能调试时很可能是调试被禁用了：打开IE 工具→Internet选项→高级→浏览（将禁用脚本点没）
//上节课补充
{
}
//函数的定义（3种方法）
{
定义函数：
function 函数名( 参数1,参数2，… )
{
语句;
}
如果函数不包含return语句，返回undefined
var f = new Function("x", "y", "return x*y;"); //一般不用，效率太低
等同于：
function f(x, y) { return x*y; }
var f=function(x){return x*x}
函数直接量是一个表达式，他可以定义匿名函数
}
//函数的调用
{
调用函数：使用运算符（）来调用它 ;
调用函数的注意事项
（1）不能给函数的参数指定一个函数类型
（2）Javascript不会检测传递的数据是不是那个函数所要求的类型
（3）也不会检测传递给他的参数个数是否正确
}
//函数的递归
{
var a = function aa(b) { //aa是方便后面调用
if (b <= 1) {
return 1;
}
return b * aa(b - 1);
}
document.write(a(5)); //相当于：5*4*3*2*1 显示120
}
//函数并不只是一种语法，还可以是数据
{
var aa = new Array(3);
aa[0] = function(x) {
return x * x;
}
aa[1] = 20;
aa[2] = aa[0](aa[1]);
document.write(aa[2]); //显示：400
}
//做为方法的函数
{
var calculator={
num1:1, !注意是“，”!
num2:1,
compute:function(){this.result=this.num1+this.num2;} //calculator相当于一个类 this.result相当于函数自定义了一个属性
};
//debugger
calculator.compute();
document.write(calculator.result,"
"); //显示：2 //calculator.result可能点不出来
//this : 指向正在被调用的对象
function aa() {
return this.num11 * this.num22;
}
function bb(num1, num2) {
this.num11 = num1;
this.num22 = num2;
this.a = aa;
}
var b = new bb(2, 3); //要用一个变量接受一下，这个事例是模仿的类，所以就要像真正的类一样用变量new一下然后才能点出
document.write(b.a()); //显示：6
}
//Arguments
{
它是调用对象的一个特殊属性，能够计算出传入方法时实际参数的个数，它不是数组但可以用数组的方式操作它
通过Arguments[]数组改变参数的值同样会改变用参数名获取的参数值
function test(x,y,z) {
try
{
if (arguments.length != 3) {
throw new Error("未提供正确的参数个数"); //JS中的throw
}
else if (typeof (arguments[0]) != "number" || typeof (arguments[1]) != "number" || typeof (arguments[2]) != "number") {
throw new Error("参数类型错误");
}
else {
return x + y + z;
}
}
catch(exception) //exception没有提示，硬打
{
document.write(exception.message); //exception.message也没有提示
return ""; //不加return"";返回undefined
}
}
document.write(test(1,2,"3"),"
");
document.write(test(1));
document.write(test(1,3,5));
document.write("
");
function fun(x)
{
document.write(x+"
");
arguments[0]=null;//arguments[0] 命名参数x是引用同一变量的两种不同方法
document.write(x);
}
fun(12);
12
null
}
//callee
{
function aa(x) {
if(x<=1) {
return 1;
}
return x + arguments.callee(x-1); /arguments.callee()指向的就是函数aa()/
}
document.write(aa(6)); /显示：21（6+5+4+3+2+1）/
function aa(a, s, d) {
document.write(arguments.length+"
"); //显示： 1 //argument.length :实际参数的个数
document.write(arguments.callee.length + "
"); //显示： 3 //arguments.callee.length :形式参数的个数
document.write(aa.length); //显示： 3 //函数名.length :形式参数的个数
}
aa(1)
}
//函数的方法
{
call() 方法
f.call(o, 1, 2); //将f绑定到o "1,2"是f执行时需要的参数
这与下面的代码相似：
o.m = f;
o.m(1,2);
delete o.m;
//call apply
{
function Add(x,y)
{
return x+y;
}
var o = new Object();
document.write(Add.call(o,1,2),"
"); //绑定后直接返回值
//类似于
//o.m=Add;
//o.m(1,2);
//delete o.m;
document.write(Add.apply(o,[1,2])); //给的是个数组，在但是在绑定时自动拆开 本事例的结果两者相同
}
}
//模拟命名空间
{
if(typeof com=="undefined") //注意：undefined是字符串类型的要用“”
{
com=new Object(); //com前没有var
}
if(typeof com.sitepoint=="undefined") //个人觉得没什么用，可以用自己起的特别点的名字加_代替
{
com.sitepoint=new Object();
}
com.sitepoint.Bird=function()
{
this.feet=2;
this.feathers=true;
}
var tweety=new com.sitepoint.Bird();
alert("鸟有"+tweety.feet+"爪子");
}
//用new关键字创建对象
{
function Aa(w,h) //此示例模拟了一个类，this点出的方法做为本类的方法 注意：为了区分类和方法在命名时类的首字母要大写
{
this.width=w; //width作为本类的属性
this.heigh=h;
this.shuxing=function ()
{
return this.width*this.heigh;
}
}
var a=new Aa(12,12); //没次new 都创建了一个新的对象，也重复创建了"shuxing"方法，浪费内存
var b=new Aa(2,2);
var c=new Aa(3,3);
var cc=a.shuxing();
document.write(cc);
}
//使用原型创建对象（调用prototype方法） //prototype：原型
{
function P(x, y)
{
this.x = x;
this.y = y;
this.total = function()
{
return this.x+this.y;
};
}
P.prototype.z = 10; //添加对象P的原型属性 //用原型创建对象：原型对象或方法不在类中声明，在类的下面用：类名.prototype.属性名（或方法名）=值，声明后的属性和方法在调用时和普通属性方法没什么不同，只是在创建对象时不重复创建
P.prototype.total1 = function(x, y)
{ //添加对象P的原型方法
return x+y+1;
};
var t = new P(1, 2);
var t1 = new P(3,4);
t.z = 20; //动态添加属性，在java这种强类型语言中是不可能的……
document.write(" total:"+t.total()+" total1:"+t.total1(1,3)+" z:"+t.z+"");
document.write(" total:"+t1.total()+" total1:"+t1.total1(2,4)+" z:"+t1.z+"");
/显示/
total:3 total1:5 z:20
total:7 total1:7 z:10
}
//模拟类的继承（call继承）
{
function jilei(q,w)
{
this.qq=q;
this.ww=w;
this.ii=function ()
{
return this.qq*this.ww;
}
}
jilei.prototype.ee=function()
{
return this.qq+this.ww;
}
function zilei(r,t)
{
jilei.call(this,2,3); //绑定时用this代表本类
this.rr=r;
this.tt=t;
}
zilei.prototype.yy=function()
{
document.write(this.rr*this.tt);
return""; //指定返回值为空否则返回undefined
}
var jj=new zilei(4,5);
document.write(jj.ii()); //调用基类的方法不能点出只能硬打
document.write(jj.yy());
/显示/
6
20
}
/例子/
『
function xing(bian)
{
this.bianshuxing=bian;
// this.jibianxing=function ()
// {
// document.write("这是一个"+this.bianshuxing+"形");
// }
}
xing.prototype.jibianxing=function()
{
document.write("这是一个"+this.bianshuxing+"形");
}
function san(di,gao)
{
xing.call(this,3);
this.d=di;
this.g=gao;
}
san.prototype=new xing(); //在继承类的下面加上，让子类能够继承基类的所有属性包括原型方法
san.prototype.s=function()
{
document.write("三角形的底是:"+this.d+"三角形的高是:" +this.g+"面积是："+this.d*this.g/2);
}
function si(bian,bian3)
{
xing.call(this,4);
this.bian1=bian;
this.bian2=bian3;
}
si.prototype=new xing();
si.prototype.ss=function()
{
document.write("四边形的一条边为："+this.bian1+"四边形的第二条边为："+this.bian2+"面积是："+this.bian1*this.bian2);
}
debugger;
var sanj=new san(4,3);
sanj.jibianxing();
sanj.s();
var sibian=new si(7,8);
sibian.jibianxing();
sibian.ss();
』
//例子//
{
function xing(bian)
{
this.bianshuxing=bian;
this.jibianxing=function ()
{
document.write("这是一个"+this.bianshuxing+"形");
}
}
function san(di,gao)
{
xing.call(this,3);
this.d=di;
this.g=gao;
}
san.prototype.s=function()
{
document.write("三角形的底是:"+this.d+"三角形的高是:" +this.g+"面积是："+this.d*this.g/2);
}
function si(bian,bian3)
{
xing.call(this,4); //this : 指示的是正在运行的程序，在类中是new出的类名指向的东东
this.bian1=bian;
this.bian2=bian3;
}
si.prototype.ss=function()
{
document.write("四边形的一条边为："+this.bian1+"四边形的第二条边为："+this.bian2+"面积是："+this.bian1*this.bian2);
}
debugger;
var sanj=new san(4,3);
sanj.jibianxing();
sanj.s();
var sibian=new si(7,8);
sibian.jibianxing();
sibian.ss();
/显示/
{
`这是一个3形三角形的底是:4三角形的高是:3面积是：6这是一个4形四边形的一条边为：7四边形的第二条边为：8面积是：56
}
}
//不管用不用prototype方法创建，系统都会自动创建一个原型，里面有一个constructor对象，里面放的是一个指针，这个指针不随着类new出的对象里的元素的变化而变化，它能指向自己的基类
『
/例子/
123下一页阅读全文
