1 //第1章 JavaScript概述
2 /*
3 本节课主要讲解了五点，本节课要求自己能够说出来
4 1.什么是JavaScript语言
5 JavaScript是一种面向对象，解释型的脚本语言
6 2.JavaScript语言的特点
7 (1).松散型，
8 (2).对象属性
9 (3).继承机制
10 3.JavaScript的历史
11 4.ECMAScript核心
12 5.开发工具集
13 */
1 //第2章 使用JavaScript
2 /*
3 本节课主要讲解了三点内容
4 1.创建一个HTML文件
5
6 2.JavaScript标签解析
7 (1).charset,设置字符编码集，可选
8 (2).defer,脚本语言在文档被解析和显示后才执行，可选
9 (3).languge,表示脚本语言的类型，已废弃
10 (4).src,表示引入外部的javascript语言，可选
11 (5).type,代替language，表示脚本语言的类型，必选
12
13 3.JavaScript嵌入的一些问题
14 (1).平稳退化，防止没有启动JavaScript脚本语言以及不支持JavaScript
15 <noscript>
16 你没有启动JavaScript脚本语言
17 </noscript>
18
19 */
1 //第3章 语法构成、关键字保留字及变量
2 /*
3 本节课主要讲解了三点语法的构成，关键字保留字以及变量
4 1.语法构成
5 (1).JavaScript语言的核心是ECMAscript,它的变量，函数名以及操作符都是区分大小写的 ，故JavaScript也是如此
6 (2).标示符，所谓标示符就是变量，函数，属性的名称，以及函数的参数名称
7 标识符的要求：
8 a.必须以字母，下划线，$开头
9 b.其它字符可以是字母，数字，下划线和$
10 c.关键字和保留字不可以作为标识符
11 (3).注释，注释分为单行注释和多行注释
12 (4).字面量，所谓字面量就是在程序中可以直接显示的数据值，它主要包括以下七种
13 a.数字字面量, 100
14 b.字符串字面量, “haha”
15 c.布尔值字面量, boolean
16 d.正则表达式字面量, /js/gi
17 e.对象字面量, null(注意null是一个对象)
18 f.对象字面量表达式, {x:1,y:2}
19 g.数组字面量表达式, [1,2,3,4,5]
20
21 2.关键字和保留字
22 所谓关键字就是那些已经在JavaScript中使用的字符串
23 所谓保留字就是那些未被用到的字符串，但以后可能会被用作关键字的字符串
24
25 3.变量，JavaScript的变量特性有以下八种
26 a.定义一个变量用var，打印一个变量用alert
27 b.定义的变量可以不初始化(赋值)，系统会默认给这个变量一个值undefined(未定义)，未定义不代表这个变量不存在
28 c.JavaScript中的变量时弱类型，可以更改成任何类型的变量
29 d.重复定义相同变量名的变量也是允许的，但是这样不好
30 e.定义一个变量可以不适用var，这个涉及到作用域的问题
31 f.可以在一行内定义多个变量和打印多个变量
32 g.多行定义变量时，可以不加分号
33 h.在多行定义变量时，一个var可以定义很多个变量
34
35 */
36
37 var name;
38 alert(name); //定义的变量没有初始化，但系统会默认给这个变量一个值undefined(未定义)
39
40
41 var variable ="haha";
42 variable = 100; //JavaScript中的变量时弱类型，可以改变变量的类型
43 alert(variable);
44
45
46 var someVar ="heihei";
47 var someVar ="hehe"; //重复定义相同变量是允许的，但是这样没意义
48 alert(someVar);
49
50
51 noVar ="嘻嘻"; //JavaScript总定义变量可以没有var，当时这个变量涉及作用域的问题
52 alert(noVar);
53
54
55 var num =100; var str ="哼哼";alert(num);alert(str); //可以一行定义多个变量和打印
56
57
58 var $name="zhangsan"
59 var $age=100
60 var $sex //当在多行定义多个变量时，可以不加分号;
61 alert($name);
62 alert($age);
63 alert($sex);
64
65
66 var $_name="lisi"; //多行定义变量时，可以用一个var定义多个变量，但这些变量必须初始化，否则就会提示不存在这个变量
67 $_age= 99;
68 //$_sex; //经我测试这种写法有问题，当多行定义变量时，必须初始化，不然要出bug
69 alert($_name);
1 //第4章 数据类型1
2 /*
3 本节课主要讲解ECMAScript中的五种基本数据类型和一种复杂数据类型以及一个用于检测数据类型的操作符typeof
4 1.ECMAScript六种数据类型有
5 五种简单数据类型：String，Number,Boolean,Undefined,Null,一种复杂数据类型Object
6
7 2.JavaScript中操作符typeof检测的数据类型有
8 string,number,boolean,undefined,object,以及非数据类型function函数
9
10 3.Undefined类型
11 (1).Undefined的类型唯一的值是undefined，
12 (2).申明了变量但是没有赋值，那么这个变量默认的值就是undefined，
13 (3).注意一点，申明了变量没有赋值以及没有申明的变量用typeof检测得到的类型都是undefined类型
14
15 4.Null类型
16 (1).Null的类型只有一个值null，
17 (2).用null表示一个对象变量空引用
18 (3)用''表示一个字符串变量的空引用
19 (4).用0表示一个Number类型的空引用
20 (5).用flase表示一个Boolean类型的空引用
21 (6).由于null派生于undefined，ECMAScript规定它们相等为true，但是不是恒等
22
23 5.Boolean类型
24 (1).Boolean类型有两个值，true和false
25 (2).显示转换成Boolean类型
26 (3).各种类型隐式转换成Boolean类型的规则
27 a.字符串：非空字符串为true，空字符串为false
28 b.数字：非零和无穷为true，0和NaN为false
29 c.对象：任何对象为true，null为false
30 d.Undefined：undefined为false
31 */
32 //第4章 数据类型2
33 /*
34 6.Number类型
35 (1).Number类型有两种：整型和浮点型
36 (2).整型有三种字面量格式
37 a.十进制
38 b.八进制,前导为0，后面是(0-7)
39 c.十六进制,前导为0x，后面是(0-F)
40 (3).浮点型
41 a.浮点型必须有一个小数点，小数点后面至少有一位数字
42 b.ECMAScript会将能够转换成整型的浮点数转换成整型
43 c.浮点数算术运算可能会不精确
44 (4).科学技术法
45 a.用科学技术法表示哪些过大或过小的数值
46 b.浮点数的最大值和最小值
47 c.正无穷和负无穷
48 d.判断一个数是否为无穷isFinite(),是则false
49 (5).NaN
50 a.0/0是NaN，正数/0是正无穷
51 b.获取NaN,Number.NaN
52 c.NaN与自身不等
53 d.NaN与任何计算都为NaN
54 e.可以用isNaN来判断判断各种数据类型是否为NaN,isNaN收到一个值后试图将这个值转换成数字以此来判断是否为NaN,对象看返回值
55 (6).Number()函数
56 a.ture转换成1
57 b.数字直接返回
58 c.null转换成0
59 d.undefined转换成NaN
60 e.数字字符串转换成数字，如果数字字符串有前导和后导0，则去掉0，只取有效数字
61 f.''转换成0
62 g.如果字符串的开头是字符后面是数字，这返回NaN
63 h.对象看返回值
64 (7).parseInt()函数处理整数转换
65 a.parseInt(“”)，返回NaN
66 b.parseInt("22.33")，小数点不是数值，会被去掉，返回22
67 c.parseInt()不但可以识别十进制，还可以识别八进制和十六进制
68 d,parseInt()还提供第二个参数，用于解决各种进制的转换
69 (8).parseFloat()函数处理浮点数专用函数
70 a.parseFloat()不识别十六进制
71
72
73 */
74 //第4章 数据类型3
75 /*
76 7.String类型
77 (1).字符串既可以用‘’也可以用“”，但必须成对出现
78 (2).字符串类型包含一些特殊的字面量（转义序列）
79 (3).ECMAScript中的字符串一旦被创建就不能被改变，只有被销毁
80 (4).toString()方法可以将除了null和undefined之外的值转换成字符串
81 (5).toString()在转换数字时，可以传入一个进制参数，表示要把数字转换成某种进制的字符串
82 (6).String()可以将任何类型的值包括null和undefined转换成字符串
83
84 8.Object类型
85 (1).创建对象的两种方式
86 (2).Object()的括号中可以传任意参数，当传入数字时还可以与其它数字计算
87 (3).可以通过new的形式创建其它对象，比如new Number(),new Boolean()
88 */
89 /*==================================================================================================*/
90 //num属于ECMAScript中是Number类型，打印出的值是3.14，typeof检测出来的类型为number
91 var num = 3.14;
92 alert (num);
93 alert(typeof num);
94
95 //stt属于ECMAScript中的String类型，打印出来的值是哈哈，typeof检测出来的类型为string
96 var str = '哈哈';
97 alert (str);
98 alert (typeof str);
99
100 //$booLean属于ECMAScript中的Boolean类型，打印出来的值是true，typeof检测出来的类型为boolean
101 var $boolean = true;
102 alert($boolean );
103 alert(typeof $boolean );
104
105 //$undefined属于ECMAScript中Undefined类型，打印出来的值是undefined，typeof检测出来的类型为undefined
106 var $undefined ;
107 alert($undefined);
108 alert (typeof $undefined);
109
110 //$null属于ECMAScript中的Null类型，打印出来的值是null，typeof检测出来的类型为object
111 var $null = null;
112 alert ($null);
113 alert (typeof $null);
114
115 //$object属于ECMAScript中的Object类型，打印出来的值[object,object]，typeof检测出来的类型为object
116 var $object = {}; //对象的第一种写法
117 alert ($object);
118 alert(typeof $object);
119
120 //obj属于ECMAScript中的Object类型，打印出来的值是[object,object]，typeof检测出来的类型为object
121 var obj = new Object(); //对象的第二种写法
122 alert (obj);
123 alert (typeof obj);
124
125 //$function不属于任何数据类型，它是一个函数，打印出它的本体，typeof检测出来的类型为function
126 var $function = function method(){
127
128 };
129 alert ($function);
130 alert(typeof $function);
131
132 /*******************************************************************************************************************************************/
133
134 //Undefined类型唯一的值undefined，声明了变量但是没有赋值默认值为undefined，声明了变量但没有赋值以及没有声明的变量的类型都是undeined
135 var $_undefined ;
136 alert ($_undefined);
137 alert(typeof $_undefined);
138 alert(typeof $unexists);
139
140 /*******************************************************************************************************************************************/
141
142 //Null类型唯一的值null，null是对象空引用
143 var $obj = null;
144 $obj = {
145 1:1
146 }
147 alert ($obj);
148
149 //’‘是字符串空引用
150 var $str = '';
151 alert($str);
152 alert(typeof $str);
153
154 //0是数字空引用
155 var $num =0;
156 alert($num);
157 alert(typeof $num);
158
159 //false是布尔空引用
160 var $_boolean = false;
161 alert ($_boolean);
162 alert(typeof $_boolean);
163
164 //null派生于undefined，故ECMAScript规定它们相等，但不恒等（因为它们类型不同）
165 alert (undefined == null);
166 alert (undefined === null); //返回false，因为它们的类型不同，一个是Undefined，一个是Object
167
168 /*******************************************************************************************************************************************/
169
170 //显示转换成Boolean类型,用Boolean()函数
171 var transform1 ='显示转换';
172 var transform2 = Boolean(transform1);
173 alert(typeof transform2);
174
175 //隐式转换Boolean规则
176 var conversion ='隐式转换';
177 if(conversion){
178 alert('true就执行我');
179 }else{
180 alert('false就执行我');
181 }
182
183 /*==================================================================================================*/
184 //数据类型2
185 /*******************************************************************************************************************************************/
186 //(1)整数
187 //十进制
188 var decimal =100;
189 alert(decimal);
190
191 //八进制，前导必须为0，数字范围（0-7）
192 var octonary =020;
193 alert(octonary);
194
195 //十六进制，前导必须为0x，数字范围（0-F）
196 var hexadecimal=0xFF;
197 alert(hexadecimal);
198
199 /*******************************************************************************************************************************************/
200 //(2)浮点数
201 //小数
202 var floating=3.13;
203 alert(floating);
204
205 //ECMAScript能够将转换成整数的小数转换成整数
206 var $_floating = 3.0;
207 alert($_floating);
208
209 //浮点数算术运算可能不精确，因此不要用浮点数运算做判断。
210 var $float1=0.2;
211 var $float2=0.4;
212 alert ($float1+$float2); //得到的结果为0.6000000000000001，虽然是十七位，但是不精确
213
214 /*******************************************************************************************************************************************/
215 //(3)科学计数法
216 //浮点数过大或过小用科学计数法来计数
217 var $count1 = 2.33e9;
218 alert($count1);
219
220 var $count2 = 2.11e-9;
221 alert($count2);
222
223
224 //浮点数的最大值和最小值
225 alert(Number.MAX_VALUE);
226 alert(Number.MIN_VALUE);
227
228
229 //正无穷和负无穷
230 alert(100e1000);
231 alert(-100e1000);
232
233
234 //获取正无穷和负无穷
235 alert(Number.POSITIVE_INFINITY);
236 alert(Number.NEGATIVE_INFINITY);
237
238 //判断是否超出无穷数，没有超过返回true
239 alert(isFinite(22));
240
241 /*******************************************************************************************************************************************/
242
243 //(4)NaN
244 //除0的情况
245 alert(0/0); //0/0为NaN
246 alert(1/0); //除0以外的数除0为无穷数
247 alert(1/0*0); //NaN
248
249 //获取NaN
250 alert(Number.NaN);
251
252 //NaN与自身不等
253 alert(NaN==NaN);
254
255 //任何数与NaN计数都是NaN
256 alert(NaN+1);
257
258 //判断一个值是不是NaN,可以判断各种类型值，宝货对象，对象看返回的值
259 alert(isNaN(33));
260
261 /*******************************************************************************************************************************************/
262 //(5)Number()函数将非数字转换成数字，用于任何数据类型
1 //第5章 运算符
2 /*
3 1.什么是表达式
4 单一的字面量和组合的字面量的运算符都可以称为表达式
5
6 2.一元运算符
7 (1).前置++(--)，后置++(--)
8 (2)其它数据类型应用前置和后置时，这些数据类型先试图转换成Number类型在运算
9 (3)单个前置+和单个前置-，它们用于放在各种数据类型前，试图将它们转换成正负Number类型
10
11 3.算术运算符
12 (1)加法
13 注意：当一个字符串+数字时，这个时候这个+就是连接符作用，而不是加法运算符
14 alert("javaScript"+5); //这个时候的+表示连接作用而不是加法运算符
15 (2)减法
16 注意：当计算的值有null或者是‘’都会转换成0
17 (3)乘法
18 注意：当计算的值有null或者是‘’都会转换成0
19 (4)除法
20 注意：当计算的值有null或者是‘’都会转换成0
21 (5)求模
22 注意：当计算中null和''作为模数的时，结果为NaN,其实就是任何数模与0都是NaN
23 alert(100%0); alert(100%undefined); alert(100%0); //任何数模以0都是NaN
24
25 以上运算都是各种数据类型相互运算，比如有整数，NaN，Infinity,-Infinity,true,null,对象，数字字符串，“”，字符字符串
26
27 4.关系运算符
28 注意(1)当比较的两个值都是数字字符串时，则会将字符串的第一个字符转变成数字进行比较
29 注意(2)当比较的两个值都是字符串时，则会将其转换成Ascii码在比较
30 注意(3)在比较时null和undefined不会自动转换成0，在计算时才会转换成0
31 alert(undefined ==0); alert(null ==0); //结果为false，因为在比较时，undefined和null不能像计算时那样自动转换成0
32
33 5.逻辑运算符
34 (1)与(&&)
35 a.当第一个操作数是对象则返回第二个操作符
36 b.当第二个操作数是对象，则第一个操作数返回true，才返回第二个操作数，否则返回false
37 c.当操作符中有一个null或者undefined则返回null或者undefined
38 d逻辑与属于短路操作，当第一个操作数为false时，不会去判断第二个操作数
39 (2)或(||)
40 a.当第一个操作数是对象，则返回第一个操作数
41 b.当第一个操作数为fasle，则返回第二个操作数
42 c.两个操作数都是对象则返回第一个操作数
43 d.当两个操作数都是null或者NaN或者undefined时，则返回null，NaN和undefined
44 e.逻辑或也是短路操作，当第一个操作数为true就不会去判断第二个操作数
45 (3).非(!)
46 a.操作数是一个对象，返回false
47 b.操作数是一个非空字符串，返回false
48 c.操作数是非0数字（包括Infinity）,返回false
49
50 6.*位运算符
51 位非(~)，位与(&)，位或(|)，位异或(^)，左移(<<)，有符号右移(>>)，无符号右移(>>>)
52
53 7.赋值运算符
54 +=，-=，*=，/=，%=，<<=，>>=，>>>=
55
56 8.其它运算符
57 (1)字符串运算符
58 字符串运算符只有一个+，作用是将两个字符串相连
59 (2)逗号运算符
60 逗号运算符可以再一条语句总执行多个操作
61 (3)三元运算符
62 if语句的简写形式
63
64 9.运算符优先级
65 对于优先级可以通过圆括号来解决
66 */
1 //第6章 流程控制语句
2 /*
3 1.if语句三种
4 (1)if(条件表达式) 语句;
5 (2)if(条件表达式) {语句;} else {语句;}
6 (3)if(条件表达式) else if(条件表达式) {语句;} ... else {语句;}
7
8 2.switch语句
9 switch语句是多重条件判断语句
10 var box = 1;
11 switch (box) {
12 case 1:
13 alert('one');
14 break;
15 case 2;
16 alert('two');
17 break;
18 case 3;
19 alert('three');
20 break;
21 default:
22 alert('default');
23 }
24
25 3.do...whilt语句
26 do...while语句是一种先运行后判断的循环语句
27 var box =1:
28 do{
29 alert(box);
30 box++;
31 }while(box<=5);
32
33 4.while语句
34 while语句是先判断后执行的循环语句
35 var box =1;
36 while(box<=5) {
37 alert(box);
38 box++;
39 }
40
41 5.for语句
42 for语句是先判断后执行循环的的语句
43 for(var box =1;box<=5;box++)
44 {
45 alert(box);
46 }
47
48 6.for...in语句
49 for...in语句是一种精准的迭代语句，用于枚举对象的属性
50 var box ={
51 'name':李炎龟,
52 'age':28,
53 'height':178
54 };
55 for(var property in box) {
56 alert(prpperty);
57 }
58
59 7.break和continue语句
60 break退出当前循环不在执行循环语句
61 continue退出本次循环继续下次循环
62
63 8.with语句
64 with语句的作用是将代码的作用域设置到一个特定的对象中
65 var box ={
66 'name' : '李炎龟',
67 'age' : 25,
68 'height' :125
69 };
70 with(box) {
71 var n = name;
72 var a =age;
73 var h = height;
74 }
75
76
77
78 */
79
80 for(var x=1;x<=10;x++)
81 {
82 if(x==5)continue; //注意break和continue必须在一行，不然报错
83 document.write(x+"<br/>");
84 }
85
86
87 var box ={
88 'name' : '李炎龟',
89 'age' : 25,
90 'height' :125
91 }
92 with(box) {
93 var n = name;
94 var a =age;
95 var h = height;
96 }
97 alert(n+a+h);
1 //第7章 函数
2 /*
3 1.函数
4 (1).既不带参数也没有返回值的函数
5 function method1() {
6 alert('哈哈');
7 }
8 menthod1();
9
10 (2).带参数但没有返回值的函数
11 function method2(name,age) {
12 alert("我的名字叫"+name+"，年龄"+age);
13 }
14 method2("张三",33);
15
16 (3).不带参数但是有返回值的函数
17 function method3() {
18 return "哇哈哈";
19 }
20 alert(method3());
21
22 (4).既带参数又有返回值的函数
23 function menthod4(name,age) {
24 return "大爷叫"+name+"年龄"+age;
25 }
26 alert(method4('风车车',280));
27
28 (5).return
29 return的另一个功能就是退出当前函数，注意break用于循环和swith中，而return用于函数中
30 function method5(num) {
31 if(num<5) return num; //如果直接写return则返回undifined
32 return "哈哈";
33 }
34 alert(method5(8));
35
36 2.arguments对象
37 ECMAScript中的函数可以传很多不同类型的参数，在函数体内部可以通过arguments对象来接收这些参数
38 (1),可以通过agruments来接收传递进来的参数
39 function method6() {
40 return arguments[0]+'|'+arguments[1]+'|'+arguments[7]; //没有的元素用undefined表示
41 }
42 alert(method6(11,22,33,44,55));
43
44 (2).可以通过arguments对象查看传入多少个参数
45 function menthod7() {
46 return argument.length();
47 }
48 alert(method7(2,"",3,1,3,4,5));
49
50 (3).综合以上两种可以智能计算传进来数字的和
51 function method8() {
52 var sum=0;
53 if(arguments.length==0) return sum;
54 for(var x=0;x<arguments.length;x++)
55 {
56 sum+=arguments[x];
57 }
58 return sum;
59 }
60 alert(sum);
61
62 3.ECMAScript中的函数没有重载功能
63 所谓的重载就是函数名相同，但是参数个数和类型不同
64
65 function method(num,str) {
66 return num+str;
67 }
68 function method(num) {
69 return num+100;
70 }
71 function method(num) {
72 return num+200;
73 }
74 alert(method(50,"ddd")); //会选择最后给的方法，不会选择第一个方法
75
76
77 */
78
79
80
1 //第8章 对象和数组
2 /*
3 1.Object类型
4 ECMAScript中对象是一种引用类型，引用类型是一种结构，ECMAScript中没有传统面向对象中的类和接口
5 (1).使用new运算符创建对象
6 (2).使用new运算符创建对象时可以省略new关键字
7 var obj = Object(); //用new 运算符创建对象时可以省略new关键字
8 obj.name="张三"; //传统赋值方式
9 alert(obj.name);
10
11 (3).使用字面量方式创建对象
12 (4).使用字面量方式创建对象时，属性字段可以使用字符串形式
13 (5)使用字面量方式创建对象，也可以用传统的赋值方式
14 (6).读取对象属性的两种方式
15 var obj ={
16 name : '张三',
17 age : 24
18 }
19 alert(obj.name);
20 alert(obj['age']);
21 (7).给对象创建方法(注意2点)
22 a.注意点1,给new对象创建方法时
23 function objRun() {
24 return '张三';
25 }
26 var obj = new Object() ;
27 obj.run = objRun(); //alert(obj.run)打印函数返回值
28 obj.run = objRun //alert(obj.run);打印出整个函数,alert(obj.run())打印的是函数返回值
29
30 b.注意点2，给字面量对象方法时
31 var obj = {
32 run : function() {
33 return '李四';
34 }
35 }
36 alert(obj.run); //打印出整个函数
37 alert(obj.run()); //打印出函数返回值
38 (8).使用delete删除对象属性
39 (9).给方法传递匿名对象
40 function method(obj) {
41 if(obj.name!=undefined) alert(obj.name);
42 if(obj.age!=undefined) alert(obj.age);
43 }
44 method({ //将匿名对象作为参数传递
45 name : '张三',
46 age : 100
47 })
48
49 2.Array类型
50 ECMAScript中的Array类型中的元素可以保存任意类型，并且大小可以调整
51 (1)使用new关键字创建数组
52 var arr = new Array(); //用new关键字创建一个空数组
53 var arr = new Array(10); //用new关键字创建一个数组，并指定大小
54 var arr = new Array('张三','28,'男'); //用new关键字创建一个数组，并分配了几个元素
55
56 (2)使用new关键字创建数组可以省略new关键字
57 (3)使用字面量方式创建数组
58 var arr =[] ; //用字面量方式创建一个空数组
59 var arr =['张三',22,'男']; //用字面量方式创建一个数组，并分配了几个元素
60
61 (4)使用索引下标读取、修改以及添加数组的元素
62 var arr =['张三','李四','王麻子'];
63 alert(arr[1]); //用索引下标读取数组元素
64 arr[1] = '猪八戒'; //用索引下标修改数组元素
65 alert(arr[1]);
66 arr[5] = '唐僧'; //用索引下标添加元素
67
68
69 (5)使用length属性获取数组元素的个数，以及用length强制设置数组元素的长度，以及通过length为数组末尾添加一个元素
70 var arr = ['张三','李四','王麻子'];
71 alert(arr.length); //查看数组长度
72 alert(arr.length=10); //强制设置数组长度
73 alert(arr[arr.length]=1000); //通过length为数组末尾添加一个元素
74
75 3.数组中的方法
76 (1).将数组转换成字符串的四个方法
77 toString()方法，valueOf()方法，toLocaleString()方法，三个都是将数组中的值以逗号连接，然后打印出字符串，区别在于toLocaleString()方法可以本地化时间，并且这三个方法也是对象的方法
78 join()方法可以指定用什么符号将数组中的元素连接起来并打印出字符串
79 (2).栈方法(后进先出)
80 push()方法将任意元素添加到数组末尾，并返回数组的长度
81 pop()方法将数组中末尾元素去掉，然后返回移除的元素
82 (3).队列方法(先进先出)
83 push()方法将任意元素添加到数组末尾，并返回数组的长度
84 shift()方法将数组中开头元素去掉，然后返回移除 的元素
85 unshift()方法将任意元素添加到数组的开头，并返回数组的长度
86 (4).排序方法
87 reverse()方法将数组进行逆行排序，并返回排序后的数组
88 sort()方法将数组的元素进行从小到大的排序，并返回排序后的数组，但这个方法对于数字元素排序需要传递一个参数，这个参数是一一个比较方法
89
90 var arr = [4,6,1,8,200];
91 alert(arr.reverse());
92 function compare(value1,value2) {
93 if(value1<value2){
94 return -1;
95 } else if(value1>value2) {
96 return 1;
97 } else {
98 return 0;
99 }
100 }
101 alert(arr.sort(compare)); //当sort方法排序数字元素时，需要传递一个比较方法
102 (5).基于数组的操作方法
103 concat()方法基于当前数组创建一个新数组
104 var arr = ['张三','李四','王麻子'];
105 alert(arr);
106 alert(arr.concat('赵六'));
107
108 slice()方法基于当前数组获取指定区域元素并创建一个新数组
109 var arr = ['张三','李四','王麻子','赵六'];
110 alert(arr.slice(1)); //从第二个参数往后取
111 alert(arr.slice(1,3)); //取第二个到第四个之间参数
112
113 splice()方法有三种功能，删除，插入，替换
114 var arr = ['张三','李四','王麻子','赵六'];
115 alert(arr.splice(0,2)); //从0位置截取两个元素
116 alert(arr); //原数组被改变
117
118 var arr = ['张三','李四','王麻子','赵六'];
119 alert(arr.splice(1,0,'哈哈')); //从1位置添加一个元素
120 alert(arr); //原数组被改变
121
122 var arr = ['张三','李四','王麻子','赵六'];
123 alert(arr.splice(1,1,'哈哈')); //将1位置的元素替换成'哈哈'，返回删除的元素
124 alert(arr); //原数组被改变
125
126
127
//第9章 时间和日期
/*
1.Date类型
(1).var box = new Date();创建一个不传递参数的日期对象可以直接获取当前的时间和日期
(2).ECMAScript提供了Date.parse()和Date.UTC()两个方法用于将提供的日期格式转换成毫秒数
Date.parse()支持的日期格式有三种
a.月/日/年
b.英文月 日，年
c.英文星期 英文月名 日 年 时：分：秒 GMT-070
Date.parse()没有传入或者传入的不是标准日期格式，则返回NaN
Date.UTC()支持的日期格式
a.年，月，日，时，分，秒
Date.UTC()没有传入参数则会返回NaN
2.通用的方法
toLocaleString(), //打印出时间格式
toString(), //打印出时间格式
valueOf() //打印出时间的毫秒值
3.日期格式化方法
var box = new Date();
alert(box.toDateString()); //以特点的格式显示星期，月，日，年
alert(box.toTimeString()); //以特定的格式显示时，分，秒和时区
alert(box.toLocalDateString()); //以特定格式显示本地星期，月，日，年
alert(box.toLocalTimeString()); //以特定格式显示本地时，分，秒和时区
alert(box.toUTCString()); //以特定格式显示完整的UTC日期
4.组件方法
alert(box.getTime()); //获取日期的毫秒数，和valueOf()返回一致
alert(box.setTime(100)); //以毫秒数设置日期，会改变整个日期
alert(box.getFullYear()); //获取四位年份
alert(box.setFullYear(2012)); //设置四位年份，返回的是毫秒数
alert(box.getMonth()); //获取月份，没指定月份，从0 开始算起
alert(box.setMonth(11)); //设置月份
alert(box.getDate()); //获取日期
alert(box.setDate(8)); //设置日期，返回毫秒数
alert(box.getDay()); //返回星期几，0 表示星期日，6 表示星期六
alert(box.setDay(2)); //设置星期几
alert(box.getHours()); //返回时
alert(box.setHours(12)); //设置时
alert(box.getMinutes()); //返回分钟
alert(box.setMinutes(22)); //设置分钟
alert(box.getSeconds()); //返回秒数
alert(box.setSeconds(44)); //设置秒数
alert(box.getMilliseconds()); //返回毫秒数
alert(box.setMilliseconds()); //设置毫秒数
alert(box.getTimezoneOffset()); //返回本地时间和UTC 时间相差的分钟数
总结：time，FullYear，Mouth，Date，Day，Hours，Minutes，Seconds，Milliseconds都有get和set的方法，并且还可以在set和get后加上UTC
区别在于，加上UTC则表示世界协调时间，没加UTC的就是本地时间中国相差8个小时，就相当于减去8个小时
*/
//第10章 正则表达式
/*
一、正则表达式创建，测试，方法和属性
1.创建正则表达式的两种方法
(1)采用new运算符创建
var pattern = newRegExp('@');
var pattern = newRegExp('@','ig');
(2)采用字面量表达式创建
var pattern = /@/;
var pattern = /@/ig;
注意，第二个参数是模式，模式有i(忽略大小写)，g(全局匹配)，m(多行匹配)
2.RegExp的两个测试对象
(1)test()方法，返回true和false
alert(new RegExp('@','igm').test('Ysfox@gmail.com')); //返回true和false
alert(/@/igm.test('Ysfox.@gmail.com')); //返回true和false
(2)exec()方法，如果匹配到就返回匹配到的数组，没匹配到指则返回null
alert(new RegExp('@','igm').exec('Ysfox@gmail.com@')); //如果匹配到返回的是数组或则null
alert(/@/igm.exec('Ysfox@gmail.com')[1]);
3.String对象的四个正则表达式方法
(1)match(pattern) //返回的数组，数组元素为匹配到的元素
(2)replace(pattern,replacement) //用replacement替换匹配到的字符
(3)search(pattern) //如果匹配到则返回第一次出现的位置，没有匹配到返回-1（注意，既然只返回第一次出现的位置，正则就没有必要是全局的）
(4)split(pattern) //返回按指定正则拆分的数组
4.RegExp的静态属性,所谓静态属性就是用RegExp调用的方法
(1)input，获取要被匹配的字符串
(2)lastMatch，最终匹配到的字符串
(3)leftContext，获取匹配到的字符串左边的所有内容
(4)rightContext，获取匹配到的字符串右边的所有内容
(5)lastParen，最终匹配到的正则括号中的字符串
注意：以上方法都必须在正则执行之后才可以调用
5.RegExp的实例属性，所谓实例属性就是正则表达式直接调用的方法
(1)global，表示正则是否全局，返回布尔值
(2)ignoreCase，表示正则是否忽略大小写，返回布尔值
(3)multiline，表示正则是否支持多行匹配，返回布尔值
(4)source，返回正则的内容
(5)lastIndex，表示下次从哪个地方开始匹配
=============================================================================================
二、正则表达式元字符
1.单个字符和数字
. //匹配除换行符外的任意一个字符
[a-z0-9] //匹配括号中任意一个字符或则数字
\d //匹配任意一个数字
\w //匹配任意一个字母，数字以及_，相当于[a-z0-9_]
[^a-z0-9] //匹配一个不包括括号中的字符或则数字
\D //匹配任意一个非数字，等同于[^0-9]
\W //匹配任意一个非字母，数字以及_，相当于[^a-z0-9_]
总结：一点a-z0-9dwf非（经典）
2.空白字符
\s //匹配一个空白字符，空格，制表符换行符
\b //匹配一个空格字符
\r //匹配一个回车字符
\n //匹配一个换行符
\f //匹配一个进制符号
\t //匹配一个制表符
\S //匹配一个非空白字符
\0 //匹配一个null字符
总结：sbrnftS0（SBRNfather,S0）
3.锚字符
^ //行首匹配（向首行进）
$ //行尾匹配（用钱摆平尾）
以下不好记忆
______________________________________________
\A //匹配字符串开始处
\b //匹配单词边界
\B //匹配非边界
\G //匹配当前搜索的开始位置
\Z //匹配字符串结束处
\z //匹配字符串结束处
————————————————————————---
4.重复字符
x? //匹配0个或者1个x
x* //匹配0个或者多个x
x+ //匹配至少一个x
(xyz)+ //匹配至少一个(xyz)
x{m,n} //匹配最少m个，最多n个x
总结：x+x*x?x()+xmn
5.替换字符
this|where|logo //用于匹配this或where或logo中任意一个
6.记录字符
(string) //用于分组的
\1或$1 //匹配第一个分组中的内容
\2或$2 //匹配第二个分组中的内容
\3或$3 //匹配第三个分组中的内容
=============================================================================================
三、以下正则没有混乱，没有具体分组，自己识别
var pattern = /g..gle/;
var pattern = /g.*gle/;
var pattern = /g[a-zA-Z_]*gle/;
var pattern = /g[^0-9]*gle/;
var pattern = /[a-z][A-Z]+/;
var pattern = /g\w*gle/;
var pattern = /google\d*/;
var pattern = /\D{7,}/;
var pattern = /^google$/;
var pattern = /goo\sgle/;
var pattern = /google\b/;
var pattern = /google|baidu|bing/;
var pattern = /(google){4,8}/;
var pattern = /google{4,8}/;
var pattern = /8(.*)8/;
var pattern = /(.*)\s(.*)/;
四、贪婪和惰性（关于贪婪和惰性也很麻烦，不好记忆）
贪婪惰性
+ +?
? ??
* *?
{n} {n}?
{n,} {n,}?
{n,m} {n,m}?
*/
alert(new RegExp('@','igm').exec('Ysfox@gmail.com@')[0]);
alert(/@/igm.exec('Ysfox@gmail.com')[1]);
alert('Ysyox@gmail.com'.match(/y/img).length);
alert('Ysyox@gmail.com'.match(/y/img).toString());
alert('Ysyox@gmail.com'.replace(/y/img,'##'));
alert('Ysyox@gmail.com'.search(/y/img));
alert('Ysyox@gmail.com'.split(/@/img).toString());
var str = "This is google web!";
var reg =/(g)oogle/img;
alert(reg.test(str));
alert(RegExp.input);
alert(RegExp.lastMatch);
alert(RegExp.leftContext);
alert(RegExp.rightContext);
alert(RegExp.lastParen);
var patterm = new RegExp('google','igm');
var str1 = 'google google google';
patterm.test(str1);
alert(patterm.global);
alert(patterm.ignoreCase);
alert(patterm.multiline);
alert(patterm.source);
alert(patterm.lastIndex)
//第11章 Function类型
/*
本章主要讲解四点
1.函数的三种声明方式
(1)一把函数的创建
function 函数名([参数]){函数体}
(2)用变量接收一个无函数名的函数
var 变量名 = function([参数]){函数体}
(3)使用new Function创建函数
var 变量名 = new Function('参数'，‘返回体’)，一般不用，但是可以说明函数也是对象
例：var func = new Function ('arg1','arg2','return arg1+arg2'); //注意参数和方法体都要用‘’
alert(func(1,2));
2.函数作为参数传递和最为另一个函数的返回值
(1)函数可以作为另一个函数的参数传递，而且也可以作为另一个函数的返回值
例：function $func(sum,num){ //将函数sum作为函数$func的参数传递
return sum(num); //将函数sum作为函数$func的返回值
}
function sum(num){
return num+10;
}
alert($func(sum,10)); //结果20
3.函数内部的两个对象arguments，this以及一个属性callee
(1)arguments对象接受传入函数中的所有参数，将这些参数装在arguments数组里面
(2)arguments对象有一个属性callee，这个属性是一个指针，执行拥有arguments对象的函数
callee属性尤其是在递归中调用自身函数时可以防止更改函数名
例：function recursion(num) {
if (num <= 1) {
return 1;
} else {
return num * arguments.callee(num-1); /arguments.callee表示拥有arguments对象的函数
}
}
alert(recursion(3));
(3)this对象代表所属作用域对象的引用，当在任意一个对象中使用到this，this就代表这个对象，其中最大的对象是window
4.函数的两个属性length，prototype以及属性prototype下两个方法apply，call
(1)函数的length属性表示这个函数中参数的个数
例：alert(recursion.length);
(2)每个函数都包含apply()和call()这两个非继承而来的方法,
apply()和call()这两个方法可以在一个函数里面冒充另一个函数
apply和call的区别在于apply传入的参数是以数组的形式传递，而call是直接传递
另外apply和call真正的用处在于扩展函数作用域，
例：待定，还未理解
*/
//使用new Function创建函数
var func = new Function ('arg1','arg2','return arg1+arg2'); //注意参数和方法体都要用‘’
alert(func(1,2)); //注意用变量传值
//函数可以作为另一个函数的参数传递，而且也可以作为另一个函数的返回值
function $func(sum,num){ //将函数sum作为函数$func的参数传递
return sum(num); //将函数sum作为函数$func的返回值
}
function sum(num){
return num+10;
}
alert($func(sum,10)); //结果20
//callee属性尤其是在递归中调用自身函数时可以防止更改函数名
function recursion(num) {
if (num <= 1) {
return 1;
} else {
return num * arguments.callee(num-1); //arguments.callee表示拥有arguments对象的函数
}
}
alert(recursion(3));
//函数的length属性，表示函数的参数个数
alert(recursion.length);
//apply()方法的作用是在一个函数中冒充另一函数
//第12章 变量、作用域及内存
/*
前言：JavaScript的变量是松散型的，可以在脚本生命周期内任意改变变脸的值以及数据类型
1.变量
(1).基本类型和引用类型
ECMAScript变量值有两种，基本类型和引用类型，
基本类型的变量指向的是基本数据类型，引用类型的变量实际上指向的是引用类型在堆内存中的地址
基本类型数据存放在栈空间，大小固定，引用类型数据存放在堆空间大小不定
基本类型按值访问，引用类型按引用方法访问
(2).基本类型的变量和引用类型的变量添加属性
为基本类型的变量添加属性不成功，属性的结果为undefined
为引用类型的变量添加属性成功，属性的结果为添加的内容
(3).基本类型的变量之间的复制和引用类型的变量之间的复制
基本类型的变量之间的复制是值本身，复制之后两变量指向相互独立的两个值
引用类型的变量之间的复制是引用类型在堆内存中的地址值，复制之后两变量指向的是同一个对象
(4).ECMAScript中所有函数的参数都是按值传递的
所谓按值传递就是将基本数据类型的值复制一份传递给函数，这样原来的基本数据类型就不会改变
所谓按引用传递就是将引用类型的地址传递给函数，引用传递会改变原来的引用数据类型
但是无论是传递的是基本数据类型还是引用数据类型，都是将栈空间中的数据类型复制一份然后传递给函数
所以无论是传递基本数据类型还是传递引用数据类型本质上都是按值传递
注意：以上是java中的概念
(5)检测数据类型
typeof运算符用于检测数据的类型
instanceof运算符用于判断是否为某种引用数据类型（注意：当用instanceof检测基本数据类型的时候，会返回false）
2.作用域
(1)JavaScript中window对象被认为是全局环境，全局的变量和函数都是window对象的属性和方法
(2)当执行环境中的代码执行完毕之后，这个执行环境也就被销毁了，执行环境中的变量和函数也随同销毁
(3)每个执行环境都有一个类似于window的变量对象，环境中定义的所有变量和函数都保存在这个对象中
（但是我们无法像访问window对象那样访问它们，只有解析器可以使用它们）
(4)在局部作用域里的声明的变量只在局部环境中起作用，如果将全局变量作为参数传递给局部作用域，
这个变量也只能在局部环境中起作用，因为javascript是按值传递，也就是将全局变量复制了一份传递给局部环境
在局部环境中改变传递进来的参数，不影响全局的变量
(5)当在函数中声明的变量没有用var声明，这个变量是全局变量
(6)在函数体内还包含函数，只有这个函数访问内层函数，这是由于作用域链的缘故，只能父类层环境访问子类层环境中的属性和函数
(7)没有块级作用域的语句有if语句，for语句，也就是说再它的花括号中没有局部作用域
(8)在局部环境中查询使用变量，如果局部中的变量名和全局中的变量名相同，则局部中有则访问局部的，局部没有在访问全局的
3.JavaScript具有自动垃圾回收机制，当一个数据没有了指向就视为垃圾，所以我们要销毁内存中的一个数据，只要把变量赋值为null就可以
*/
//ECMAScript中所有函数的参数都是按值传递的
function func1(arg){ //传递基本数据类型
arg=100;
return arg
}
var num = 10;
func1(10);
alert(num); //结果为10，也就是说函数传递是按值传递的，就是将栈内存中的num赋值一份传递给函数，num本身没有改变
function func2(arg){ //传递引用数据类型
arg.name ="哈哈";
}
var obj = new Object();
func2(obj);
alert(obj.name); //结果返回“哈哈”，传递引用数据类型也是将栈内存中的引用地址复制一份然后传递给函数，地址指向同一个对象，所以函数中改变对象，外面的指向也跟着改变
//检测数据类型
var arr = [1,2,3];
var num =5;
alert(typeof num);
alert(typeof arr);
alert(arr instanceof Array);
//全局变量和全局函数都是window对象的属性和方法
var $win ="全局变量";
function win(){
return("全局函数");
}
alert(window.$win); //window对象调用自己的属性
alert(window.win()); //window对象调用自己的函数
//局部作用域中声明的变量只在局部变量中起作用，如果将全局变量作为参数传递给局部环境，那么这个参数变量也只能在局部环境中起作用
var global = "呵呵";
function globalMethod(global){
var local ="嘿嘿";
return global; //这个只是按值传递进来的一个值，它只在局部环境中有效，不影响外部变量
}
globalMethod("哈哈");
alert(global);
//alert(local); //在外部不起作用，只会提示没有定义
//在函数中不用var定义的变量为全局变量
function method(){
$global = "this is a global varible";
}
method(); //别忘记调用一下方法
alert($global)
//在函数体内还包含函数，只有这个函数访问内层函数
function outsideMethod(){
var outsideArg = "我是外部方法的属性";
function insideMethod(){
var insideArg = "我是内部方法的属性";
return insideArg;
}
alert(insideMethod()); //方法中的方法只能在父类方法中访问,理由是作用域链的缘故
return outsideArg;
}
alert(outsideMethod()); //全局中的函数可以在全局中访问
//if语句，for语句没有作用域，也就是没有块级作用域
if(true){
var ifArg = "if语句中的变量是全局变量";
}
alert(ifArg);
for(var i =0;i<10;i++){
var forArg = "for语句中的变量是全局变量";
}
alert(i);
alert(forArg);
//在局部环境中查询使用变量，如果局部中的变量名和全局中的变量名相同，则局部中有则访问局部的，局部没有在访问全局的
var someVar = "外部相同变量";
function run(){
var someVar = "内部相同变量";
return someVar;
}
alert(run());
//第13章 基本包装类型
/*
本节课主要讲解
(1)基本包装类型的概述
ECMAScript中提供了3个特殊的引用类型：Boolean、Number、String。
当用字面量声明的时候就是基本数据类型，当用new运算符声明的时候就是引用数据类型
字面量声明不能创建属性和方法，因为它不是引用类型
当用new运算符声明就可以创建属性和方法
无论用字面量声明还是用new运算符声明都可以用它的内置方法
(2)Boolean类型
Boolean类型没有特定的属性和方法
(3)Number类型
静态属性
Number.MAX_VALUE
Number.MIN_VALUE
Number.NaN
Number.NEGATIVE_INFINITY
Number.POSITIVE_INFINITY
Number.prototype //原型，用于增加新属性和方法
Number对象的方法
toString() //将数字转换成String类型
toLocaleString() //将这个数字转换成本地数字格式化成String
toFixed() //小数点后保留几位，括号中传入要保留几位的数字
toExponential() //将数字以指数形式表示，括号中可以传入保留几位小数，结果为字符串
toPrecision() //将数字以指数形式表示或点数表示，括号中传入保留几位小数，结果为字符串
(4)String类型
(4.1).String对象的三大属性length，constructor，prototype
length，返回字符串字符的长度
constructor，返回创建String对象的构造函数
prototype，为源字符串添加属性和方法
(4.2)String对象也包含对象的通用方法
toString()
toLocaleString()
valueOf()
(4.3)查找单个字符的方法
charAt(索引位置) //返回指定索引位置的字符
charCodeAt(索引位置) //返回指定索引位置字符的Unicode码
字符串[索引位置] //通过数组的方式返回字符串中指定位置的字符
(4.4)字符串操作方法
contact(str1,str2,...) //将字符串参数串联到调用该方法的字符串之后
slice(n,[m]) //返回字符串n到m的之间的字符串（包含头不包含尾）,第二个参数未指定则取n之后所有字符，只有一个负数，则从（长度+负数）位置开始取，如果第二个参数也是负数也用同样的方法转换成正数
substring(n,[m]) //同上，（包含头不包含尾）第二个参数未指定则取n之后所有字符，如果只有一个参数且为负数则直接转换成0，如果第一个参数为正第二个参数为负数，则将负数转为0，并把小的数提前
substr(n,[m]) //返回字符串从位置n开始取m个字符串，（包含头不包含尾）第二个参数未指定则取n之后所有字符，只有一个负数，则从（长度+负数）位置开始取，如果第一个参数为正第二个参数为负数，则将负数转为0，
(4.5)字符串位置方法
index(str,n) //从n位置开始搜索第一个str字符，并返回搜索的索引值，如果没有找到则返回-1
lastIndexOf(str,n) //从n位置开始搜索最后一个str字符，并返回搜索的索引值，如果没有找到则返回-1
通过循环找出字符串中每个字符的所有位置
(4.6)字符串大小写转换方法
toLowerCase(str) //将字符串全部转换成小写
toUpperCase(str) //将字符串全部转换成大写
toLocaleLowerCase(str) //将字符串全部转换成小写，并且本地化（只有在少数语言中有用）
toLocaleUpperCase(str) //将字符串全部装换成大写，并且本地化（只有在少数语言中有用）
(4.7)字符串的匹配模式方法
match(pattern) //如果匹配到指定的pattern则返回pattern，如果没有匹配到则返回null
replace(pattern,replacement) //用replacement替换匹配到的pattern
search(pattern) //返回第一次匹配到pattern的位置，如果没有匹配到则返回-1
split(pattern) //返回按指定正则pattern拆分的数组
(4.8)其它方法
fromCharCode(ascii) //返回指定指定ascii数字对应的字符，它是一个静态方法
localCompare(str1,str2) //比较两个字符大小，比较的是字符ascii顺序，str1>str2为1，str1<str2为-1，str1=str2为0
(4.9)HTML方法
javascript提供了将一个字符串加上html的方法，但是一般没怎么用，这里就不再累述，如有需要请查阅文档
用法如下：
var box = 'baidu';
box.link('http://www.baidu.com');
alert(box);
*/
/*
//Number类型静态属性
alert(Number.MAX_VALUE);
alert(Number.MIN_VALUE);
alert(Number.NaN);
alert(Number.POSITIVE_INFINITY);
alert(Number.NEGATIVE_INFINITY);
//var num = new Number(10086.1415926);
var num = 10086.1415926;
alert(num.toString());
alert(num.toLocaleString());
alert(num.toFixed(2));
alert(num.toExponential(4));
alert(num.toPrecision(4));
//字符串操作方法
var str = "abcdefg";
alert(str.length);
alert(str.slice(2)); //取从2开始之后所有的字符
alert(str.slice(-2)) //取从（length+(-2)）开始之后的字符
alert(str.slice(2,3)); //取2到3之间的字符，包含头不包含尾
alert(str.slice(2,-3)); //如果第二个数是负数，则将负数转换成正数（length+(-3)），那么结果就是从2到4
alert(str.slice(-1,-3)); //没有结果，同上负数转换为正数方法，结果从6到4，自然没有结果
alert(str.substring(2)); //从2开始取之后所有的字符
alert(str.substring(-2)); //如果只有一个参数且为负数则直接转换趁0，就是从0开始取之后所有的字符
alert(str.substring(2,3)); //取从2到3之间的字符，包含头不包含尾巴
alert(str.substring(2,-2)); //当两个参数，第二个参数为负数，则将负数直接转换成0，并将较小的那个数提前，所以这个是从0到2，
alert(str.substring(-2,-3)); //当两个参数都是负数，则都转换成0,0到0自然不能取到字符
alert(str.substr(2)); //从2号位置取之后所有的字符
alert(str.substr(-2)); //将负数转换成正数，用字符长度加-2，就是从位置5开始取之后所有的字符
alert(str.substr(2,3)); //从2号位置取3个字符
alert(str.substr(2,-3)); //从2号位置取-3个字符，自然娶不到
alert(str.substr(-2,-3)); //第一个字符转换成正数就是5，从5号位置开始取-3个字符自然娶不到
//通过循环找出字符串中每个字符的所有位置
var str = 'abcabcabcabc';
var arr =[];
var pos = str.indexOf('c');
while(pos>-1){
arr.push(pos);
pos = str.indexOf('c',pos+2);
}
alert(arr);
//HTML方法，很少用
var web = 'baidu';
web.bold(); //添加加粗html代码
web.link('http://www.baidu.com'); //添加网址html代码
alert(web);
*/
//内置对象
/*
本章主要讲解两个内置对象，内置对象是已经实例化的对象，开发人员不能显示实例化内置对象
(1)Global内置对象
Global内置对象是ECMAScript中一个特殊的对象，所有在全局作用域定义的变量和函数都是Gobal对象的属性和方法
由于这个对象是内置的，没法定义，所以不能用Global来调用它的属性和方法。可以直接写它的属性和方法或者用window调用
Global对象中的内置属性和方法
(1.1)URI编码和解码
URI编码是对连接进行编码的，它采用特殊的UTF-8编码替换连接中的无效字符
encodeURI() //它不会对连接本身的一些特殊字符进行编码，例如冒号，正斜杠，问号，井号 ，也就是说它只编码连接中的中文
encodeURIComponent() //它会对它连接中的所有特殊字符进行编码，也就是说它比encodeURI()更彻底，不但多中文编码还多其它特殊字符编码
有编码就有解码，注意解码时要用对应的解码方法
decodeURI() //专门用于解码encodeURI编码
decodeURIComponent() //专门用于解码encodeURIComponent编码
(1.2)eval()方法用于将字符串解析成javascript代码，它接受的参数就是一段javascript代码字符串
(1.3)Global对象属性
只要是全局的,也就是说是window对象的属性就是Global对象的属性,注意Global比window范围大，Global属于ECMASCript，而window属于web浏览器
例如：undefined，NaN，Object，Array，Function
(2)Math内置对象
(2.1)Math对象的属性
web开发不怎么用，要用自己查，此处不再累述
(2.2)Math对象方法min()和max(),用于在一组数值中选出最大值和最小值
(2.3)Math对象的三个舍入方法
ceil() //向上舍入
floor() //向下舍入
round() //标准舍入
(2.4)Math对象的随机方法random(),它返回介于0和1之间的一个随机数，不包含0和1
要想获取1-10之间的一个随机数则先将得到的随机数*10加1就，然后用向下舍人就可以得到1-10之间的随机数
将获取任意一段数字之间的随机数写成一个函数，方便调用
*/
//URI编码和解码
var link = 'http://www.百度.com';
alert(encodeURI(link));
alert(encodeURIComponent(link));
alert(decodeURI(encodeURI(link)));
alert(decodeURIComponent(encodeURIComponent(link)));
//eval()用于将字符串代码解析成javascript代码
eval("alert('哈哈')");
eval("function run(){alert('嘿嘿');}");
run();
//Global对象属性
alert(NaN);
alert(Function);
//Math对象方法min()和max(),用于在一组数值中选出最大值和最小值
alert(Math.min(2,4,3,6,3,8,0,1,3)); //最小值
alert(Math.max(4,7,8,3,1,9,6,0,3,2)); //最大值
//Math对象的三个舍入方法
alert(Math.ceil(3.1));
alert(Math.floor(3.9));
alert(Math.round(3.5));
//Math对象的随机方法random()
alert(Math.random());
alert(Math.floor(Math.random()*10+1)); //获取1-10之间的随机数
for(var i =0;i<10;i++){
document.write(Math.floor(Math.random()*10+5)); //循环10次获取5到14之间的随机数
document.write("<br />");
}
//将获取任意一段数字之间的随机数写成一个函数，方便调用
function scopeRondom(lower,upper){
var num = upper-lower+1
return Math.floor(Math.random()*num+lower);
}
for(var i =0 ;i<5;i++){
document.write(scopeRondom(1000000,9999999)); //获取100到1000之间的一个随机数
document.write("<br />");
}
浙公网安备 33010602011771号