2

3

4

5

6

1 直接编写

    <script>

        alert(‘hello yuan‘)

    </script>

2 导入文件

    <script src="hello.js"></script>

2

3

x=5

y=6

z=x+y

2

var a;

a=3;

var name="yuan", age=20, job="lecturer";

2

3

4

5

6

7

8

9

Camel 标记法

首字母是小写的，接下来的字母都以大写字符开头。例如：

var myTestValue = 0, mySecondValue = "hi";

Pascal 标记法

首字母是大写的，接下来的字母都以大写字符开头。例如：

Var MyTestValue = 0, MySecondValue = "hi";

匈牙利类型标记法

在以 Pascal 标记法命名的变量前附加一个小写字母（或小写字母序列），说明该变量的类型。例如，i 表示整数，s 表示字符串，如下所示“

Var iMyTestValue = 0, sMySecondValue = "hi";

2

3

4

5

6

7

8

9

10

11

function func1(){

        var a = 123;

        b=456

    }

    func1();

//    alert(a);

//    alert(b);

// 不推荐

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

a=1;b=2;

a=1 b=2;------错误

a=1

b=2

//推荐

a=1;

b=2;

{

 a=1;

 b=2;

    //推荐加tab

    a=1;

    b=2;

}

2

3

4

5

6

7

8

/*

        number     -----  数值

        boolean    -----  布尔值

        string     -----  字符串

        undefined  -----  undefined

        null       -----   null 

 */

2

2进制: 1111 0011 1101 0100   <-----> 16进制:0xF3D4 <-----> 10进制:62420

2进制: 1 111 001 111 010 100 <-----> 8进制:0171724

2

3

4

5

6

7

简介

是由Unicode字符、数字、标点符号组成的序列

字符串常量首尾由单引号或双引号括起

JavaScript中没有字符类型

常用特殊字符在字符串中的表达

字符串中部分特殊字符必须加上右划线\

常用的转义字符 \n:换行  \‘:单引号   \":双引号  \\:右划线

2

3

4

<script>

        var str="\u4f60\u597d\n欢迎来到\"JavaScript世界\"";

        alert(str);

</script>

2

3

4

5

if (x==1){

      y=y+1;

}else{

      y=y-1;

      }

2

3

4

5

6

7

8

9

10

JavaScript属于松散类型的程序语言

变量在声明的时候并不需要指定数据类型

变量只有在赋值的时候才会确定数据类型

表达式中包含不同类型数据则在计算过程中会强制进行类别转换

数字 + 字符串：数字转换为字符串

数字 + 布尔值：true转换为1，false转换为0

字符串 + 布尔值：布尔值转换为字符串true或false

2

3

4

5

函数parseInt：   强制转换成整数   例如parseInt("6.12")=6  ; parseInt(“12a")=12 ; parseInt(“a12")=NaN  ;parseInt(“1a2")=1

函数parseFloat： 强制转换成浮点数  parseFloat("6.12")=6.12

函数eval：       将字符串强制转换为表达式并返回结果 eval("1+1")=2 ; eval("1<2")=true

2

3

4

5

加(＋)、 减(－)、 乘(*) 、除(/) 、余数(% )  加、减、乘、除、余数和数学中的运算方法一样  例如：9/2=4.5，4*5=20，9%2=1

-除了可以表示减号还可以表示负号  例如：x=-y

+除了可以表示加法运算还可以用于字符串的连接  例如："abc"+"def"="abcdef"

2

3

4

5

6

7

8

9

假如x=2，那么x++表达式执行后的值为3，x--表达式执行后的值为1

i++相当于i=i+1，i--相当于i=i-1

递增和递减运算符可以放在变量前也可以放在变量后：--i

var i=1;

console.log(i++);

console.log(++i);

console.log(i--);

console.log(--i);

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

var a=1;

    var b=1;

    a=-a;  //a=-1

    var c="10";

    alert(typeof (c));

    c=+c;    //类型转换

    alert(typeof (c));

//    -------------------

    var d="yuan";

    d=+d;

    alert(d);//NaN:属于Number类型的一个特殊值,当遇到将字符串转成数字无效时,就会得到一个NaN数据

    alert(typeof(d));//Number

    //NaN特点:

    var n=NaN;

    alert(n>3);

    alert(n<3);

    alert(n==3);

    alert(n==NaN);

    alert(n!=NaN);//NaN参与的所有的运算都是false,除了!=

2

3

4

5

6

7

8

等于 ( == )  、不等于( != ) 、 大于( > ) 、 小于( < ) ?大于等于(>=) 、小于等于(<=)

与 (&&) 、或(||) 、非(!)

1 && 1 = 1  1 || 1 = 1

1 && 0 = 0  1 || 0 = 1

0 && 0 = 0  0 || 0 = 0

!0=1

!1=0

2

3

4

5

6

7

赋值 =

JavaScript中=代表赋值，两个等号==表示判断是否相等

例如，x=1表示给x赋值为1

if (x==1){...}程序表示当x与1相等时

if(x==“on”){…}程序表示当x与“on”相等时

 配合其他运算符形成的简化表达式

例如i+=1相当于i=i+1，x&=y相当于x=x&y

2

3

4

5

6

7

8

9

10

== “2”       

=== “2”       

!= “4”           

!== “4”       

var a = 2; var b = 4;

var c = a<b | --b>--a;

var c = a<b || --b>--a;

 var c = a<b &&--b>--a;

var c = a<b & --b>--a;

2

var bResult = "Blue" < "alpha";

alert(bResult); //输出 true　　

2

var bResult = "25" < "3";

alert(bResult); //输出 "true"

2

var bResult = "25" < 3;

alert(bResult); //输出 "false"

2

比较运算符两侧如果一个是数字类型,一个是其他类型,会将其类型转换成数字类型.

比较运算符两侧如果都是字符串类型,比较的是最高位的asc码,如果最高位相等,继续取第二位比较.

2

3

4

5

6

7

var temp=new Object();// false;[];0; null; undefined;object(new Object();)

    if(temp){

        console.log("yuan")

    }else {

        console.log("alex")

    }

2

3

4

5

6

7

8

9

10

11

if-else基本格式

if (表达式){

语句１;

......

}else{

语句２;

.....

}

功能说明

如果表达式的值为true则执行语句1,

否则执行语句2

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

var x= (new Date()).getDay();

//获取今天的星期值，0为星期天

var y;

if ( (x==6) || (x==0) ) {

y="周末";

}else{

y="工作日";

}

alert(y);

//等价于

y="工作日";

if ( (x==6) || (x==0) ) {

y="周末";

}

2

3

4

5

6

7

8

9

10

if语句嵌套格式

if (表达式1) {

    语句1;

}else if (表达式2){

    语句2;

}else if (表达式3){

    语句3;

} else{

    语句4;

}

2

3

4

5

6

7

8

9

10

11

if (x==1){

    y="星期一";

}else if (x==2){

    y="星期二";

...

}else if (x==6){

    y="星期六";

}else if (x==0){

    y="星期日";

}else{

    y="未定义";

2

3

4

5

6

7

switch基本格式

switch (表达式) {

    case 值1:语句1;break;

    case 值2:语句2;break;

    case 值3:语句3;break;

    default:语句4;

}

2

3

4

5

6

7

8

9

10

switch(x){

case 1:y="星期一";    break;

case 2:y="星期二";    break;

case 3:y="星期三";    break;

case 4:y="星期四";    break;

case 5:y="星期五";    break;

case 6:y="星期六";    break;

case 7:y="星期日";    break;

default: y="未定义";

}

2

3

4

5

6

7

for循环基本格式

for (初始化;条件;增量){

    语句1;

    ...

}

功能说明

实现条件循环，当条件成立时，执行语句1，否则跳出循环体

2

3

4

5

6

7

8

9

10

for (var i=1;i<=7;i++){

    document.write("<H"+i+">hello</H "+i+"> ");

    document.write("<br>");

}

----------------------------------------------

    var arr=[1,"hello",true]//var dic={"1":"111"}

    for (var i in arr){

        console.log(i)

        console.log(arr[i])

    }

2

3

4

5

6

7

8

9

10

11

12

13

14

doms=document.getElementsByTagName("p");

    for (var i in doms){

       console.log(i); // 0 1 2 length item namedItem

       //console.log(doms[i])

    }

//循环的是你获取的th一个DOM元素集，for in用来循环对象的所有属性，dom元素集包含了你上面输出的属性。

//如果你只要循环dom对象的话，可以用for循环:

    for (var i=0;i<doms.length;i++){

        console.log(i) ; // 0 1 2

        //console.log(doms[i])

    }

2

3

4

5

6

7

while循环基本格式

while (条件){

语句1；

...

}

功能说明

运行功能和for类似，当条件成立循环执行语句花括号{}内的语句，否则跳出循环

2

3

4

5

6

7

var i=1;

while (i<=7) {

    document.write("<H"+i+">hello</H "+i+"> ");

    document.write("<br>");

    i++;

}

//循环输出H1到H7的字体大小

2

3

4

5

6

7

8

9

10

11

12

<script language="JavaScript">

/* sayhello是定义的函数名，前面必须加上function和空格*/

function sayHello(){

    var hellostr;

    var myname=prompt("请问您贵姓？","徐");

    hellostr="您好，"+myname+‘小姐，欢迎进入"探索之旅"！‘;

    alert(hellostr);

    document.write(hellostr);

}

 //这里是对前面定义的函数进行调用

sayHello();

</script>

2

3

4

5

6

7

8

9

10

try {

    //这段代码从上往下运行，其中任何一个语句抛出异常该代码块就结束运行

}

catch (e) {

    // 如果try代码块中抛出了异常，catch代码块中的代码就会被执行。

    //e是一个局部变量，用来指向Error对象或者其他抛出的对象

}

finally {

     //无论try中代码是否有异常抛出（甚至是try代码块中有return语句），finally代码块中始终会被执行。

}

2

ToString() :  返回对象的原始字符串表示。

ValueOf()  : 返回最适合该对象的原始值。对于许多对象，该方法返回的值都与 ToString() 的返回值相同。

2

3

4

5

6

7

8

9

10

<script language="javascript">

var aa=Number.MAX_VALUE;

//利用数字对象获取可表示最大数

var bb=new String("hello JavaScript");

//创建字符串对象

var cc=new Date();

//创建日期对象

var dd=new Array("星期一","星期二","星期三","星期四");

//数组对象

</script>

2

3

var str1="hello world";

alert(str1.length);

alert(str1.substr(1,5));

2

3

var str1= new String("hello word");

alert(str1.length);

alert(str1.substr(1,3));

2

获取字符串长度

length

2

3

4

5

6

7

8

9

书写格式:

String对象提供了一组针对HTML格式的方法，如x.anchor()返回锚定义字符串<a>x</a>，

x.bold()返回粗体表示字符串<b>x</b>，x.sup()返回上标格式字符串<sup>x</sup>。

-----------------------------------------

var x="xyp";

var y="x.italics():"+x.italics();

document.write(y.fontsize(10));//<font size="10">x.italics():<i>yuan</i></font>

2

3

4

5

6

7

8

var str1="AbcdEfgh";

var str2=str1.toLowerCase();

var str3=str1.toUpperCase();

alert(str2);

//结果为"abcdefgh"

alert(str3);

//结果为"ABCDEFGH"

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

书写格式

x.charAt(index)

x.charCodeAt(index)

使用注解

x代表字符串对象

index代表字符位置

index从0开始编号

charAt返回index位置的字符

charCodeAt返回index位置的Unicode编码

----------------------

var str1="welcome to the world of JS! 徐二";

var str2=str1.charAt(28);

var str3=str1.charCodeAt(28);

alert(str2);

//结果为"徐"

alert(str3);

//结果为33489

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

//书写格式

//

//x.indexOf(findstr,index)

//x.lastIndexOf(findstr)

//-------------------------------------

var str1="welcome to the world of JS!";

var str2=str1.indexOf("l");

var str3=str1.lastIndexOf("l");

alert(str2);

//结果为2

alert(str3);

//结果为18

//-------*********************************************************-------

//书写格式

//

//x.match(regexp)

//

//x.search(regexp)

//

//使用注解

//

//x代表字符串对象

//

//regexp代表正则表达式或字符串

//

//match返回匹配字符串的数组，如果没有匹配则返回null

//

//search返回匹配字符串的首字符位置索引

//-------------------------------------

var str1="welcome to the world of JS!";

var str2=str1.match("world");

var str3=str1.search("world");

alert(str2[0]);

//结果为"world"

alert(str3);

//结果为15

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

//截取子字符串

//

//书写格式

//

//x.substr(start, length)

//

//x.substring(start, end)

//

//使用注解

//

//x代表字符串对象

//

//start表示开始位置

//

//length表示截取长度

//

//end是结束位置加1

//

//第一个字符位置为0

var str1="abcdefgh";

var str2=str1.substr(2,4);

var str3=str1.substring(2,4);

alert(str2);

//结果为"cdef"

alert(str3);

//结果为"cd"

//-------*********************************************************-------

//x.slice(start, end)

var str1="abcdefgh";

var str2=str1.slice(2,4);

var str3=str1.slice(4);

var str4=str1.slice(2,-1);

var str5=str1.slice(-3,-1);

alert(str2);

//结果为"cd"

alert(str3);

//结果为"efgh"

alert(str4);

//结果为"cdefg"

alert(str5);

//结果为"fg"

2

3

4

5

6

//x.replace(findstr,tostr)

var str1="abcdefgh";

var str2=str1.replace("cd","aaa");

alert(str2);

//结果为"abaaaefgh"

2

3

4

5

6

var str1="一,二,三,四,五,六,日";

var strArray=str1.split(",");

alert(strArray[1]);

//结果为"二"

2

3

4

5

6

7

8

9

10

11

12

13

//y=x.concat(addstr)

//

//使用注解

//

//x代表字符串对象

//addstr为添加字符串

//返回x+addstr字符串

var str1="abcd";

var str2=str1.concat("efgh");

alert(str2);

//结果为"abcdefgh"

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

Array 对象用于在单个的变量中存储多个值。

语法:

创建方式1:

var a=[1,2,3];

创建方式2:

new Array();     //  创建数组时允许指定元素个数也可以不指定元素个数。

new Array(size);//if 1个参数且为数字,即代表size,not content

    初始化数组对象:

    var cnweek=new Array(7);

        cnweek[0]="星期日";

        cnweek[1]="星期一";

        ...

        cnweek[6]="星期六";

new Array(element0, element1, ..., elementn)//也可以直接在建立对象时初始化数组元素，元素类型允许不同

var test=new Array(100,"a",true);

2

3

4

5

6

7

8

9

10

11

var cnweek=new Array(7);

for (var i=0;i<=6;i++){

    cnweek[i]=new Array(2);

}

cnweek[0][0]="星期日";

cnweek[0][1]="Sunday";

cnweek[1][0]="星期一";

cnweek[1][1]="Monday";

...

cnweek[6][0]="星期六";

cnweek[6][1]="Saturday";

2

3

4

5

6

7

8

9

10

11

12

复制代码

var cnweek=new Array(7);

cnweek[0]="星期日";

cnweek[1]="星期一";

cnweek[2]="星期二";

cnweek[3]="星期三";

cnweek[4]="星期四";

cnweek[5]="星期五";

cnweek[6]="星期六";

for (var i=0;i<cnweek.length;i++){

  document.write(cnweek[i]+" | ");

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

//书写格式

//x.join(bystr)

//使用注解

//

//x代表数组对象

//bystr作为连接数组中元素的字符串

//返回连接后的字符串

//与字符串的split功能刚好相反

var arr1=[1, 2, 3, 4, 5, 6, 7];

var str1=arr1.join("-");

alert(str1);

//结果为"1-2-3-4-5-6-7"

2

3

4

5

6

7

8

9

10

11

12

13

14

//连接数组-concat方法

//

//x.concat(value,...)

var a = [1,2,3];

var a = new Array(1,2,3);

var b=a.concat(4,5) ;

alert(a.toString());

//返回结果为1,2,3

alert(b.toString());

//返回结果为1,2,3,4,5

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

//x.reverse()

//x.sort()

var arr1=[32, 12, 111, 444];

//var arr1=["a","d","f","c"];

arr1.reverse(); //颠倒数组元素

alert(arr1.toString());

//结果为444,111,12,32

arr1.sort();    //排序数组元素

alert(arr1.toString());

//结果为111,12,32,444

//------------------------------

arr=[1,5,2,100];

//arr.sort();

//alert(arr);

//如果就想按着数字比较呢?

function intSort(a,b){

    if (a>b){

        return 1;//-1

    }

    else if(a<b){

        return -1;//1

    }

    else {

        return 0

    }

}

arr.sort(intSort);

alert(arr);

function IntSort(a,b){

    return a-b;

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//x.slice(start, end)

//

//使用注解

//

//x代表数组对象

//start表示开始位置索引

//end是结束位置下一数组元素索引编号

//第一个数组元素索引为0

//start、end可为负数，-1代表最后一个数组元素

//end省略则相当于从start位置截取以后所有数组元素

var arr1=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘,‘h‘];

var arr2=arr1.slice(2,4);

var arr3=arr1.slice(4);

var arr4=arr1.slice(2,-1);

alert(arr2.toString());

//结果为"c,d"

alert(arr3.toString());

//结果为"e,f,g,h"

alert(arr4.toString());

//结果为"c,d,e,f,g"

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//x. splice(start, deleteCount, value, ...)

//

//使用注解

//

//x代表数组对象

//splice的主要用途是对数组指定位置进行删除和插入

//start表示开始位置索引

//deleteCount删除数组元素的个数

//value表示在删除位置插入的数组元素

//value参数可以省略

var a = [1,2,3,4,5,6,7,8];

a.splice(1,2);

//a变为 [1,4,5,6,7,8]

alert(a.toString());

a.splice(1,1);

 //a变为[1,5,6,7,8]

alert(a.toString());

a.splice(1,0,2,3);

 //a变为[1,2,3,5,6,7,8]

alert(a.toString());

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

//push pop这两个方法模拟的是一个栈操作

//x.push(value, ...)  压栈

//x.pop()             弹栈     

//使用注解

//

//x代表数组对象

//value可以为字符串、数字、数组等任何值

//push是将value值添加到数组x的结尾

//pop是将数组x的最后一个元素删除

var arr1=[1,2,3];

arr1.push(4,5);

alert(arr1);

//结果为"1,2,3,4,5"

arr1.push([6,7]);

alert(arr1)

//结果为"1,2,3,4,5,6,7"

arr1.pop();

alert(arr1);

//结果为"1,2,3,4,5"

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

// unshift shift

//x.unshift(value,...)

//x.shift()

//使用注解

//

//x代表数组对象

//value可以为字符串、数字、数组等任何值

//unshift是将value值插入到数组x的开始

//shift是将数组x的第一个元素删除

var arr1=[1,2,3];

arr1.unshift(4,5);

alert(arr1);

//结果为"4,5,1,2,3"

arr1. unshift([6,7]);

alert(arr1);

//结果为"6,7,4,5,1,2,3"

arr1.shift();

alert(arr1);

//结果为"4,5,1,2,3"

2

3

4

5

6

7

8

9

//  js中数组的特性

         //java中数组的特性,  规定是什么类型的数组,就只能装什么类型.只有一种类型.

         //js中的数组特性1: js中的数组可以装任意类型,没有任何限制.

         //js中的数组特性2: js中的数组,长度是随着下标变化的.用到多长就有多长.

         var arr5 = [‘abc‘,123,1.14,true,null,undefined,new String(‘1213‘),new Function(‘a‘,‘b‘,‘alert(a+b)‘)];

        /*  alert(arr5.length);//8

         arr5[10] = "hahaha";

         alert(arr5.length); //11

         alert(arr5[9]);// undefined */

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

//方法1：不指定参数

var nowd1=new Date();

alert(nowd1.toLocaleString( ));

//方法2：参数为日期字符串

var nowd2=new Date("2004/3/20 11:12");

alert(nowd2.toLocaleString( ));

var nowd3=new Date("04/03/20 11:12");

alert(nowd3.toLocaleString( ));

//方法3：参数为毫秒数

var nowd3=new Date(5000);

alert(nowd3.toLocaleString( ));

alert(nowd3.toUTCString());

//方法4：参数为年月日小时分钟秒毫秒

var nowd4=new Date(2004,2,20,11,12,0,300);

alert(nowd4.toLocaleString( ));

//毫秒并不直接显示

2

3

4

5

6

7

8

9

10

11

获取日期和时间

getDate()                 获取日

getDay ()                 获取星期

getMonth ()               获取月（0-11）

getFullYear ()            获取完整年份

getYear ()                获取年

getHours ()               获取小时

getMinutes ()             获取分钟

getSeconds ()             获取秒

getMilliseconds ()        获取毫秒

getTime ()                返回累计毫秒数(从1970/1/1午夜)

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

function getCurrentDate(){

        //1. 创建Date对象

        var date = new Date(); //没有填入任何参数那么就是当前时间

        //2. 获得当前年份

        var year = date.getFullYear();

        //3. 获得当前月份 js中月份是从0到11.

        var month = date.getMonth()+1;

        //4. 获得当前日

        var day = date.getDate();

        //5. 获得当前小时

        var hour = date.getHours();

        //6. 获得当前分钟

        var min = date.getMinutes();

        //7. 获得当前秒

        var sec = date.getSeconds();

        //8. 获得当前星期

        var week = date.getDay(); //没有getWeek

        // 2014年06月18日 15:40:30 星期三

        return year+"年"+changeNum(month)+"月"+day+"日 "+hour+":"+min+":"+sec+" "+parseWeek(week);

    }

alert(getCurrentDate());

//解决 自动补齐成两位数字的方法

    function changeNum(num){

    if(num < 10){

        return "0"+num;

    }else{

        return num;

    }

}

//将数字 0~6 转换成 星期日到星期六

    function parseWeek(week){

    var arr = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六"];

    //             0      1      2      3 .............

    return arr[week];

}

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

//设置日期和时间

//setDate(day_of_month)       设置日

//setMonth (month)                 设置月

//setFullYear (year)               设置年

//setHours (hour)         设置小时

//setMinutes (minute)     设置分钟

//setSeconds (second)     设置秒

//setMillliseconds (ms)       设置毫秒(0-999)

//setTime (allms)     设置累计毫秒(从1970/1/1午夜)

var x=new Date();

x.setFullYear (1997);    //设置年1997

x.setMonth(7);        //设置月7

x.setDate(1);        //设置日1

x.setHours(5);        //设置小时5

x.setMinutes(12);    //设置分钟12

x.setSeconds(54);    //设置秒54

x.setMilliseconds(230);        //设置毫秒230

document.write(x.toLocaleString( )+"<br>");

//返回1997年8月1日5点12分54秒

x.setTime(870409430000); //设置累计毫秒数

document.write(x.toLocaleString( )+"<br>");

//返回1997年8月1日12点23分50秒 

2

3

4

5

6

7

8

9

10

11

12

日期和时间的转换:

getTimezoneOffset():8个时区×15度×4分/度=480;

返回本地时间与GMT的时间差，以分钟为单位

toUTCString()

返回国际标准时间字符串

toLocalString()

返回本地格式时间字符串

Date.parse(x)

返回累计毫秒数(从1970/1/1午夜到本地时间)

Date.UTC(x)

返回累计毫秒数(从1970/1/1午夜到国际时间)

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

//RegExp对象

    // 在表单验证时使用该对象验证用户填入的字符串是否符合规则.

    //创建正则对象方式1  参数1 正则表达式  参数2 验证模式  g global / i 忽略大小写. //参数2一般填写g就可以，也有“gi”.

    // 用户名 首字母必须是英文, 除了第一位其他只能是英文数字和_ . 长度最短不能少于6位 最长不能超过12位

    //----------------------------创建方式1

    /* var reg1 = new RegExp("^[a-zA-Z][a-zA-Z0-9_]{5,11}$","g");

    //

    //验证字符串

    var str = "bc123";

    alert(reg1.test(str));// true

    //----------------------------创建方式2  /填写正则表达式/匹配模式;

    var reg2 = /^[a-zA-Z][a-zA-Z0-9_]{5,11}$/g;

    alert(reg2.test(str));// true

     */

    //-------------------------------正则对象的方法-------------------

        //test方法  ==>  测试一个字符串是否复合 正则规则. 返回值是true 和false.

    //-------------------------String 中与正则结合的4个方法------------------.

    // macth search split replace

    var str = "hello world";

    //alert(str.match(/o/g)); //查找字符串中 复合正则的 内容.

    //alert(str.search(/h/g));// 0  查找字符串中符合正则表达式的内容位置

    //alert(str.split(/o/g)); // 按照正则表达式对字符串进行切割. 返回数组;

    alert(str.replace(/o/g, "s")); // hells wsrld  对字符串按照正则进行替换.

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

//Math对象

    //该对象中的属性方法 和数学有关.

    //Math是内置对象 , 与Global的不同之处是, 在调用时 需要打出 "Math."前缀.

    //属性学习:

    //alert(Math.PI);

    //方法学习:

        //alert(Math.random()); // 获得随机数 0~1 不包括1.

        //alert(Math.round(1.5)); // 四舍五入

        //练习：获取1-100的随机整数，包括1和100

             //var num=Math.random();

            //num=num*10;

            //num=Math.round(num);

            // alert(num)

        //============max  min=========================

        /* alert(Math.max(1,2));// 2

        alert(Math.min(1,2));// 1 */

        //-------------pow--------------------------------

        alert(Math.pow(2,4));// pow 计算参数1 的参数2 次方.

abs(x)    返回数的绝对值。

exp(x)    返回 e 的指数。

floor(x)对数进行下舍入。

log(x)    返回数的自然对数（底为e）。

max(x,y)    返回 x 和 y 中的最高值。

min(x,y)    返回 x 和 y 中的最低值。

pow(x,y)    返回 x 的 y 次幂。

random()    返回 0 ~ 1 之间的随机数。

round(x)    把数四舍五入为最接近的整数。

sin(x)    返回数的正弦。

sqrt(x)    返回数的平方根。

tan(x)    返回角的正切。

2

3

function 函数名 (参数){?函数体;

    return 返回值;

}

2

3

4

5

6

function 函数名 (参数){

    ?函数体;

   return 返回值;

}

//another way:

var 函数名 = new Function("参数1","参数n","function_body");

2

3

4

5

6

7

8

9

10

11

12

alert(1);

function func1(){

    alert(‘hello yuan!‘);

    return 8

}

    ret=func1();

    alert(ret)

－－－－－－－－－－－－－－－－

var func1=new Function("name","alert(\"hello\"+name);")

func1("yuan")

2

3

4

5

6

7

8

9

10

<script>

    //f(); --->OK

    function f(){

        console.log("hello")

    }

    f() //----->OK

</script>

alert(func1.length)

alert(void(fun1(1,2)))

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

function func1(a,b){

    alert(a+b);

}

    func1(1,2);  //3

    func1(1,2,3);//3

    func1(1);    //NaN

    func1();     //NaN

    //只要函数名写对即可,参数怎么填都不报错.

-------------------面试题-----------

 function a(a,b){

    alert(a+b);

}

   var a=1;

   var b=2;

   a(a,b)

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

function add(a,b){

        console.log(a+b);//3

        console.log(arguments.length);//2

        console.log(arguments);//[1,2]

    }

    add(1,2)

    ------------------arguments的用处1 ------------------

    function nxAdd(){

        var result=0;

        for (var num in arguments){

            result+=arguments[num]

        }

        alert(result)

    }

    nxAdd(1,2,3,4,5)

//     ------------------arguments的用处2 ------------------

    function f(a,b,c){

        if (arguments.length!=3){

            throw new Error("function f called with "+arguments.length+" arguments,but it just need 3 arguments")

        }

        else {

            alert("success!")

        }

    }

    f(1,2,3,4,5)

2

3

4

5

6

7

8

9

10

11

12

13

// 匿名函数

    var func = function(arg){

        return "tony";

    }

// 匿名函数的应用

    (function(){

        alert("tony");

    } )()

    (function(arg){

        console.log(arg);

    })(‘123‘)

2

3

4

5

6

7

8

9

10

11

12

if(1==1){

        var s=12;

    }

    console.log(s);//12

   // ----------------------

    function f(){

        var temp=666;

    }

    f();

    console.log(temp);//Uncaught ReferenceError: temp is not defined

2

3

4

5

6

7

8

9

10

11

var city = ‘beijing‘;

    function func(){

        var city = ‘shanghai‘;

        function inner(){

            var city = ‘shenzhen‘;

            console.log(city);

        }

        inner();

    }

    func();

2

3

4

5

6

7

8

9

10

11

var city = ‘beijing‘;

function Bar(){

    console.log(city);

}

function func(){

    var city = ‘shanghai‘;

    return Bar;

}

var ret = func();

ret();    //beijing

2

3

4

5

6

7

8

9

10

11

12

var city = ‘beijing‘;

function func(){

    var city = "shanghai";

    function inner(){

        // var city = "langfang";

        console.log(city);

    }

    return inner;

}

var ret = func();

ret();

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

var city = ‘beijing‘;

function func(){

    var city = "shanghai";

    function inner(){

        // var city = "langfang";

        console.log(city);

    }

    return inner;

}

var ret = func();

ret();

var city = ‘beijing‘;

function Bar(){

    console.log(city);

}

function func(){

    var city = ‘shanghai‘;

    return Bar;

}

var ret = func();

ret();    //beijing

2

3

4

5

6

7

8

9

10

11

12

var x=1;

function foo() {

    var y = 2;

    function bar() {

        var z = 3;

    }

}

#bar的作用域链： barScopeChain=[bar.AO, foo.AO, global.VO];

#foo的作用域链： fooScopeChain=[foo.Ao, global.VO];

2

3

4

5

6

7

8

9

10

11

12

13

14

什么是AO,VO?

       在函数创建时，每个函数都会创建一个活动对象Active Object(AO)，全局对象为Global Object(VO)，创建函数的过程也就是为这个对象添加属性的过程，作用域链就是由这些绑定了属性的活动对象构成的。

        例如：找x变量；bar函数在搜寻变量x的过程中，先从自身AO对象上找，如果bar.AO存在这个属性，那么会直接使用这个属性的值，如果不存在，则会转到父级函数的AO对象，也就是foo.AO

        如果找到x属性则使用，找不到继续 在global.VO对象查找，找到x的属性，返回属性值。如果在global.VO中没有找到，则会抛出异常ReferenceError

执行上下文。

       函数在执行时会创建一个称为“执行上下文（execution context）”的内部对象，执行上下文定义了函数

       执行时的环境。每个执行上下文都有自己的作用域链，用于标识符解析，当执行上下文被创建时，而它的作用

       域链初始化为当前运行函数的[[Scope]]所包含的对象。

函数执行

       在函数执行过程中，每遇到一个变量，都会检索从哪里获取和存储数据，该过程从作用域链头部，也就是从活

       动对象开始搜索，查找同名的标识符，如果找到了就使用这个标识符对应的变量，如果没有则继续搜索作用域

       链中的下一个对象，如果搜索完所有对象都未找到，则认为该标识符未定义，函数执行过程中，每个标识符都

       要经历这样的搜索过程。

2

3

4

5

6

7

8

9

10

11

12

函数进入全局，创建VO对象，绑定x属性<入栈>

    global.VO={x=underfind; foo:reference of function}(这里只是预解析，为AO对象绑定声明的属性，函数执行时才会执行赋值语句，所以值是underfind)

 遇到foo函数，创建foo.AO，绑定y属性<入栈>

 foo.AO={y=underfind, bar:reference of function}

 遇到bar函数，创建bar.AO，绑定z属性<入栈>

  bar.AO={z:underfind}

作用域链和执行上下文都会保存在堆栈中，所以：

bar函数的scope chain为：[0]bar.AO-->[1]foo.AO-->[2]global.VO

      foo函数的scope chain为：[0]foo.AO-->[1]global.Vo

//建议：少定义全局变量

//理由：因为作用域链是栈的结构，全局变量在栈底，每次访问全局变量都会遍历一次栈，//这样会影响效率

2

3

4

5

6

7

8

9

10

11

12

13

14

15

for (var i=1; i<=9; i++) {

     setTimeout( function timer(){

     console.log( i );

     },1000 );

 }

//＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

for (var i=1; i<=9; i++) {

    (function(){

      var j = i;

      setTimeout( function timer(){

           console.log( j );

      }, 1000 );

     })();

2

3

4

5

window对象

    所有浏览器都支持 window 对象。

    概念上讲.一个html文档对应一个window对象.

    功能上讲: 控制浏览器窗口的.

    使用上讲: window对象不需要创建对象,直接使用即可.

2

3

4

5

6

7

8

9

10

11

alert()            显示带有一段消息和一个确认按钮的警告框。

confirm()          显示带有一段消息以及确认按钮和取消按钮的对话框。

prompt()           显示可提示用户输入的对话框。

open()             打开一个新的浏览器窗口或查找一个已命名的窗口。

close()            关闭浏览器窗口。

setInterval()      按照指定的周期（以毫秒计）来调用函数或计算表达式。

clearInterval()    取消由 setInterval() 设置的 timeout。

setTimeout()       在指定的毫秒数后调用函数或计算表达式。

clearTimeout()     取消由 setTimeout() 方法设置的 timeout。

scrollTo()         把内容滚动到指定的坐标。

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

//----------alert confirm prompt----------------------------

    //alert(‘aaa‘);

    /* var result = confirm("您确定要删除吗?");

    alert(result); */

    //prompt 参数1 : 提示信息.   参数2:输入框的默认值. 返回值是用户输入的内容.

    // var result = prompt("请输入一个数字!","haha");

    // alert(result);

    方法讲解:   

        //open方法 打开和一个新的窗口 并 进入指定网址.参数1 : 网址.

        //调用方式1

            //open("http://www.baidu.com");

        //参数1 什么都不填 就是打开一个新窗口.  参数2.填入新窗口的名字(一般可以不填). 参数3: 新打开窗口的参数.

            open(‘‘,‘‘,‘width=200,resizable=no,height=100‘); // 新打开一个宽为200 高为100的窗口

        //close方法  将当前文档窗口关闭.

            //close();

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

var num = Math.round(Math.random()*100);

    function acceptInput(){

    //2.让用户输入(prompt)    并接受 用户输入结果

    var userNum = prompt("请输入一个0~100之间的数字!","0");

    //3.将用户输入的值与 随机数进行比较

            if(isNaN(+userNum)){

                //用户输入的无效(重复2,3步骤)

                alert("请输入有效数字!");