JavaScript——基于原型编程、多范式的动态脚本语言

JavaScript是运行在浏览器上的脚本语言。简称JS。
JavaScript是网景公司（NetScape）的布兰登艾奇（JavaScript之父）开发的，最初叫做LiveScript。
LiveScript的出现让浏览器更加的生动了，不再是单纯的静态页面了。页面更具有交互性。
在历史的某个阶段，SUN公司和网景公司他们之间有合作关系，SUN公司把LiveScript的名字修改为JavaScript。
JavaScript这个名字中虽然带有“Java”但是和Java没有任何关系，只是语法上优点类似。他们运行的位置不同，Java运行在JVM当中，JavaScript运行在浏览器的内存当中。
网景公司1998年被美国在线收购。网景公司最著名的就是领航者浏览器：Navigator浏览器。
LiveScript的出现，最初的时候是为Navigator浏览器量身定制一门语言，不支持其他浏览器。
当Navigator浏览器使用非常广泛的时候，微软害怕了，于是微软在最短的时间内组建了一个团队，
开始研发只支持IE浏览器的脚本语言，叫做JScript。
JavaScript和JScript并存的年代，程序员是很痛苦的，因为程序员要写两套程序。在这种情况下，有一个非营利性组织站出来了，叫做ECMA组织（欧洲计算机协会）ECMA根据JavaScript制定了ECMA-262号标准，叫做ECMA-Script。
现代的javascript和jscript都实现了ECMA-Script规范。（javascript和jscript统一了。）

1.2 JS的特性

JavaScript程序不需要我们程序员手动编译，编写完源代码之后，浏览器直接打开解释执行。
JavaScript的“目标程序”以普通文本形式保存，这种语言都叫做“脚本语言”。
Java的目标程序已.class形式存在，不能使用文本编辑器打开，不是脚本语言。

1.3 JS的组成

完整的JavaScript由语言基础,BOM,DOM组成

ECMAScript：JS的核心语法（ES规范 / ECMA-262标准）
DOM：Document Object Model（文档对象模型：对网页当中的节点进行增删改的过程。）HTML文档被当做一棵DOM树来看待。
```
var domObj = document.getElementById("id");
```
BOM：Browser Object Model（浏览器对象模型）
关闭浏览器窗口、打开一个新的浏览器窗口、后退、前进、浏览器地址栏上的地址等，都是BOM编程

1.4 JSP和JS的区别

JSP : JavaServer Pages（隶属于Java语言的，运行在JVM当中）
JS : JavaScript（运行在浏览器上。）

02 在HTML中嵌入JS代码的三种方式

2.1 事件与事件句柄

事件：JS是一门事件驱动型的编程语言，依靠事件去驱动，然后执行对应的程序。在JS中有很多事件，其中有一个事件叫做：鼠标单击，单词：click
事件句柄：并且任何事件都会对应一个事件句柄叫做：onclick
事件和事件句柄的区别是：事件句柄是在事件单词前添加一个on。而事件句柄是以HTML标签的属性存在的。
οnclick= “js代码” 的执行原理
页面打开的时候，js代码并不会执行，只是把这段JS代码注册到按钮的click事件上了。等这个按钮发生click事件之后，注册在onclick后面的js代码会被浏览器自动调用。
怎么使用JS代码弹出消息框？
在JS中有一个内置的对象叫做window，全部小写，可以直接拿来使用，window代表的是浏览器对象。
window对象有一个函数叫做:alert，用法是：window.alert(“消息”);这样就可以弹窗了。

应用案例

script标签javascript代码必须放在script标签中，用户点击以下按钮，弹出消息框

2.2 第一种方式（事件句柄式）：

事件句柄=“js代码”，把这段代码注册到onclick之后，有操作后，js代码会在浏览器被自动调用
弹窗消息的用法是：window.alert(“消息”)
JS中的一条语句结束之后可以使用分号“;”，也可以不用
JS中的字符串可以使用双引号，也可以使用单引号，内双外单或者内单外双。

<input type="button" value="hello" onclick="window.alert('hello js')"/>
<input type="button" value="hello" onclick='window.alert("hello jscode")'/>

alert弹窗中window可以省略

<input type="button" value="hello" onclick='alert("hello jscode")'/>

完整示列代码：

<!doctype html>
<html>
	<head>
		<title>HTML中嵌入JS代码的第一种方式</title>
	</head>
	<body>

	<input type="button" value="hello" onclick="window.alert('hello js')"/>

	<input type="button" value="hello" onclick='window.alert("hello jscode")'/>

	<input type="button" value="hello" onclick="window.alert('hello zhangsan')
												window.alert('hello lis')
												window.alert('hello wangwu')"/>

	<!-- window. 可以省略。-->
	<input type="button" value="hello" onclick="alert('hello zhangsan')
												alert('hello lis')
												alert('hello wangwu')"/>

	</body>
</html>

2.3 第二种方式（脚本块）：

通过脚本块的方式，页面打开的时候执行，并且遵守自上而下的顺序依次逐行执行。（这个代码的执行不需要事件）。（CSS为样式块）

javascript的脚本块在一个页面当中可以出现多次。
javascript的脚本块出现位置也没有要求，
alert有阻塞当前页面加载的作用。（阻挡，直到用户点击确定按钮。）

脚本块的格式为script

<script type="text/javascript">
	window.alert("first.......");
</script>

完整代码如下

<script type="text/javascript">
	window.alert("first.......");
</script>
<!doctype html>
<html>
	<head>
		<title>HTML中嵌入JS代码的第二种方式</title>
		<script type="text/javascript">
			window.alert("head............");
		</script>
	</head>
	<body>
        <input type="button" value="我是一个按钮对象1" />

            <!--第二种方式：脚本块的方式-->
            <script type="text/javascript">

                window.alert("Hello World!"); // alert函数会阻塞整个HTML页面的加载。
            </script>

            <input type="button" value="我是一个按钮对象" />

	</body>
</html>

2.4 第三种方式（外部引入js文件）：

同一个js文件可以被引入多次，但实际开发中这种需求很少
引入js文件的同时再写代码，文件会被执行，但代码块不会被执行。

完整代码如下

<!doctype html>
<html>
	<head>
		<title>HTML中嵌入JS代码的第三种方式：引入外部独立的js文件。</title>
	</head>
	<body>	
	<script type="text/javascript" src="js/1.js">
		// 这里写的代码不会执行。
		// window.alert("Test");
	</script>

	<script type="text/javascript">
		alert("hello jack!");
	</script>
	</body>
</html>

js文件

window.alert("hello js!");
window.alert("hello js!");
window.alert("hello js!");

03 变量

3.1 变量的声明与赋值

java中要求变量声明的时候是什么类型，不可变。编译期强行固定变量的数据类型称为强类型语言。数据类型变量名;
对比javascript，javascript是一种弱类型语言，没有编译阶段，一个变量可以随意赋值，赋什么类型的值都行，var 变量名;

var i = 100;
i = false;
i = "abc";

当系统没有赋值的时候，会默认给undefined，undefined是系统的一个存在值
当系统直接没声明直接调用一个值，会报错

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>关于JS中的变量</title>
	</head>
	<body>
		<script type="text/javascript">
		var a, b, c = 200;
		   alert("a = " + a);
		   alert("b = " + b);
		   alert("c = " + c);
	   a = false;
	   alert(a);
	   
	   a = "abc";
	   alert(a);
	   
	   a = 1.2;
	   alert(a);
	   
	</script>
</body>
</html>

3.2 函数的定义与使用

JS函数类似Java中的方法

Java中定义方法的格式是

[修饰符列表] 返回值类型方法名(形式参数列表){
方法体;
}

public static boolean login(String username,String password){
	...
	return true;
}

boolean loginSuccess = login("admin","123");

JS是一种弱类型，JS中的函数不需要指定返回值类型，返回什么类型都行

函数的定义格式是

//第一种方式：
function 函数名(形式参数列表){
	函数体;
}
//第二种方式：
函数名 = function(形式参数列表){
	函数体;
}

例如函数

function sum(a, b){
    // a和b都是局部变量,他们都是形参(a和b都是变量名，变量名随意。)
    alert(a + b);
}

sum(10,20);//函数必须调用才能执行

//或者第二个格式
// 定义函数sayHello
sayHello = function(username){
	alert("hello " + username);
}
		   
// 调用函数
sayHello("zhangsan");

配合单击按钮框的逻辑完整代码如下

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>JS函数初步</title>
	</head>
	<body>
		<script type="text/javascript">
		function sum(a, b){
		   // a和b都是局部变量,他们都是形参(a和b都是变量名，变量名随意。)
		   alert(a + b);
	   }

	   sayHello = function(username){
		   alert("hello " + username);
	   }
	   
	   // 调用函数
	   sayHello("zhangsan");
	   
	</script>
	
	<input type="button" value="hello" onclick="sayHello('jack');" /> 
	<input type="button" value="计算10和20的求和" onclick="sum(10, 20);" />
	
</body>
</html>

重载的含义是：方法名或者函数名一样，形参不同（个数、类型、顺序）

JS当中的函数在调用的时候，参数的类型没有限制，并且参数的个数也没有限制，js本身自带重载。（弱类型）
在JS当中，函数的名字不能重名，当函数重名的时候，后声明的函数会将之前声明的同名函数覆盖

完整代码如下:

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>JS函数初步</title>
	</head>
	<body>
		<script type="text/javascript">
		   function sum(a, b){
			   return a + b;
		   }
	   // 调用函数sum
	   var retValue = sum(1, 2);
	   alert(retValue);
	   
	   var retValue2 = sum("jack"); // jack赋值给a变量,b变量没有赋值系统默认赋值undefined
	   alert(retValue2); // jackundefined
	   
	   var retValue3 = sum();
	   alert(retValue3); // NaN (NaN是一个具体存在的值，该值表示不是数字。Not a Number)
	   
	   var retValue4 = sum(1, 2, 3);
	   alert("结果=" + retValue4); // 结果=3
	   
	   function test1(username){
		   alert("test1");
	   }
	   
	   /*
	   在JS当中，函数的名字不能重名，当函数重名的时候，后声明的函数会将之前声明的同名函数覆盖。
	   */
	   function test1(){
		   alert("test1 test1");
	   }
	   
	   test1("lisi"); // 这个调用的是第二个test1()函数.
	   
	</script>
</body>
</html>

3.3 全局变量和局部变量

在函数体之外声明的变量属于全局变量；在函数体当中声明的变量，包括一个函数的形参都属于局部变量
全局变量的生命周期是浏览器打开时声明，浏览器关闭时销毁，尽量少用。因为全局变量会一直在浏览器的内存当中，耗费内存空间
局部变量的生命周期是：函数开始执行时局部变量的内存空间开辟，函数执行结束之后，局部变量的内存空间释放，局部变量生命周期较短

演示代码

// 全局变量
var username = "jack";
function accessUsername(){
// 局部变量
 var username = "lisi";
// 就近原则:访问局部变量
 alert("username = " + username);
 }
 // 调用函数
 accessUsername();
// 访问全局变量
 alert("username = " + username);

先输出lisi后输出jack
因为局部变量结束后便释放了，所以局部变量没有值
而如果单纯没有定义全局变量，全在全局中输出局部变量那会报错

function accessAge(){
var age = 20;
alert("年龄 = " + age);
}
		   
accessAge();
		   
// 报错(语法不对)
 alert("age = " + age);

如果一个变量在声明的时候没有定义var，默认是全局变量（即使在局部变量中声明）

// 以下语法是很奇怪的.
function myfun(){
// 当一个变量声明的时候没有使用var关键字,那么不管这个变量是在哪里声明的,都是全局变量.
myname = "dujubin";
 }
		   
// 访问函数
myfun();
		   
alert("myname = " + myname); // myname = dujubin

04 数据类型

原始类型：Undefined、Number、String、Boolean、Null
引用类型：Object以及Object的子类

var i;
alert(typeof i); // "undefined"

var k = 10;
alert(typeof k); // "number"

var f = "abc";
alert(typeof f); // "string"

var d = null;
alert(typeof d); // "object"  null属于Null类型,但是typeof运算符的结果是"object"

var flag = false;
alert(typeof flag); // "boolean"

var obj = new Object();
alert(typeof obj); // "object"

// sayHello是一个函数.
function sayHello(){

}
alert(typeof sayHello); // "function"

注意区分

var d = null;
alert(typeof d); // "object"  null属于Null类型,但是typeof运算符的结果是"object"

typeof：这个运算符可以在程序的运行阶段动态的获取变量的数据类型
typeof运算符的运算结果是以下6个字符串之一：注意字符串都是全部小写。“undefined”、“number”、“string”、“boolean”、“object”、“function”

在JS当中比较字符串是否相等使用“==”完成。没有equals

typeof运算符的语法格式：
typeof 变量名

function sum(a, b){
   if(typeof a == "number" && typeof b == "number"){
	   return a + b;
   }
   alert(a + "," + b + "必须都为数字！");
}

4.1 undefined

当一个变量没有手动赋值，系统默认赋值undefined或者也可以给一个变量手动赋值undefined

var i; // undefined
var k = undefined; // undefined

alert(i == k); // true

var y = "undefined"; // "undefined"是一个字符串类型
alert(y == k); // false

4.2 Number

Number类型包括整数、小数、正数、负数、不是数字、无穷大等
-1 0 1 2 2.3 3.14 100 … NaN Infinity等都属于Number

// Infinity (当除数为0的时候，结果为无穷大)
alert(10 / 0);

4.2.1 NaN

表示Not a Number，不是一个数字，但属于Number类型。运算结果本来应该是一个数字,最后算完不是一个数字的时候,结果是NaN

var a = 100;
var b = "中国人";
alert(a / b); // 除号显然最后结果应该是一个数字,但是运算的过程中导致最后不是一个数字,那么最后的结果是NaN

var e = "abc";
var f = 10;
alert(e + f); // "abc10"，但此处的加号不是应该数字，而是字符串的拼接

4.2.2 关于Number的函数

isNaN()函数

is Not a Number
isNaN(数据) ,结果是true表示不是一个数字, 结果是false表示是一个数字

function sum(a, b){
   if(isNaN(a) || isNaN(b)){
	   alert("参与运算的必须是数字！");
	   return;
   }
   return a + b;
}
sum(100, "abc");
alert(sum(100, 200));

parseInt()或者parseFloat()，

可以将字符串自动转换成数字
并且取整数位

alert(parseInt("3.9999")); // 3
alert(parseInt(3.9999)); // 3

// parseFloat():可以将字符串自动转换成数字.
alert(parseFloat("3.14") + 1); // 4.14
alert(parseFloat("3.2") + 1); // 4.2

Math.ceil()

向上取整

// Math.ceil()
alert(Math.ceil("2.1")); // 3

4.3 Boolean

对应true和false

// 规律:“有"就转换成true,"没有"就转换成false.
alert(Boolean(1)); // true
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("abc")); // true
alert(Boolean(null)); // false
alert(Boolean(NaN)); // false
alert(Boolean(undefined)); // false
alert(Boolean(Infinity)); // true

Boolean()，Boolean()函数的作用是将非布尔类型转换成布尔类型

语法格式：
Boolean(数据)

4.4 Null

null就一个值，区别要与typedf区分开来

// Null类型只有一个值,null
alert(typeof null); // "object"

4.5 String

String是一个内置的类，可以直接用，String的父类是Object

在JS当中字符串可以使用单引号，也可以使用双引号

//两种创建对象的方式，但创建的对象的类型有所不同
//第一种：
var s = "abc";
//第二种（使用JS内置的支持类String）： 
var s2 = new String("abc");

// 小string(属于原始类型String)
var x = "king";
alert(typeof x); // "string"

// 大String(属于Object类型)
var y = new String("abc");
alert(typeof y); // "object"

4.5.1 常用函数

函数名	功能
indexOf	获取指定字符串在当前字符串中第一次出现处的索引
lastIndexOf	获取指定字符串在当前字符串中最后一次出现处的索引
replace	替换(只替换了第一个)
substr	截取子字符串
substring	截取子字符串
toLowerCase	转换小写
toUpperCase	转换大写
split	拆分字符串

alert("http://www.baidu.com".indexOf("http")); // 0
alert("http://www.baidu.com".indexOf("https")); // -1

// 判断一个字符串中是否包含某个子字符串？
alert("http://www.baidu.com".indexOf("https") >= 0 ? "包含" : "不包含"); // 不包含

// replace (注意：只替换了第一个)
alert("name=value%name=value%name=value".replace("%","&")); // name=value&name=value%name=value

// 继续调用replace方法,就会替换第“二”个.
// 想全部替换需要使用正则表达式.
alert("name=value%name=value%name=value".replace("%","&").replace("%", "&")); // name=value&name=value&name=value

4.5.2 substr和substring的区别

JS的下标从0开始

// substr(startIndex, length)
alert("abcdefxyz".substr(2,4)); //cdef，（下标，长度）
// substring(startIndex, endIndex) 注意:不包含endIndex
alert("abcdefxyz".substring(2,4)); //cd，（开始下标，结束下标）

4.6 Object

Object类型是所有类型的超类，自定义的任何类型，默认继承Object

JS定义类的语法：

第一种方式：
    function 类名(形参){

    }
第二种方式：
    类名 = function(形参){

    }

创建对象的语法：

new 构造方法名(实参); // 构造方法名和类名一致。

js的类定义以及探讨

// 定义一个学生类
function Student(){
   alert("Student.....");
}

// 当做普通函数调用
Student();

// 当做类来创建对象
var stu = new Student();
alert(stu); // [object Object]

JS中的类的定义,同时又是一个构造函数的定义
在JS中类的定义和构造函数的定义是放在一起来完成的
js的函数形参调用可以有一个或者多个都可以执行，因为是弱类型

function User(a, b, c){ // a b c是形参,属于局部变量.
   // 声明属性 (this表示当前对象)
   // User类中有三个属性:sno/sname/sage
   this.sno = a;
   this.sname = b;
   this.sage = c;
}

// 创建对象
var u1 = new User(111, "zhangsan", 30);
// 访问对象的属性
alert(u1.sno);
alert(u1.sname);
alert(u1.sage);

var u2 = new User(222, "jackson", 55);
alert(u2.sno);
alert(u2.sname);
alert(u2.sage);

// 访问一个对象的属性,还可以使用这种语法
alert(u2["sno"]);
alert(u2["sname"]);
alert(u2["sage"]);

也可以换种方式定义类

Product = function(pno,pname,price){
   // 属性
   this.pno = pno;
   this.pname = pname;
   this.price = price;
   // 函数
   this.getPrice = function(){
	   return this.price;
   }
}

var xigua = new Product(111, "西瓜", 4.0);
var pri = xigua.getPrice();
alert(pri); // 4.0

属性有：prototype属性（常用的，主要是这个）：作用是给类动态的扩展属性和函数。

// 可以通过prototype这个属性来给类动态扩展属性以及函数
Product.prototype.getPname = function(){
   return this.pname;
}

// 调用后期扩展的getPname()函数
var pname = xigua.getPname();
alert(pname)

// 给String扩展一个函数
String.prototype.suiyi = function(){
   alert("这是给String类型扩展的一个函数，叫做suiyi");
}

"abc".suiyi();

4.7 null、NaN和undefined

数据类型不一致
==(等同运算符：只判断值是否相等)
===(全等运算符：既判断值是否相等，又判断数据类型是否相等)
null和undefined可以等同

// null NaN undefined 数据类型不一致.
alert(typeof null); // "object"
alert(typeof NaN); // "number"
alert(typeof undefined); // "undefined"

// null和undefined可以等同.
alert(null == NaN); // false
alert(null == undefined); // true
alert(undefined == NaN); // false

// 在JS当中有两个比较特殊的运算符
alert(null === NaN); // false
alert(null === undefined); // false
alert(undefined === NaN); // false

05 JS事件

任何一个事件都会对应一个事件句柄，事件句柄是在事件前添加on
onXXX这个事件句柄出现在一个标签的属性位置上。（事件句柄以属性的形式存在。）

5.1 常用事件

焦点是光标的获得与失去

blur失去焦点
focus获得焦点

鼠标点击事件

click鼠标单击
dblclick鼠标双击

键盘事件

keydown键盘按下
keyup键盘弹起

鼠标事件

mousedown鼠标按下
mouseover鼠标经过
mousemove鼠标移动
mouseout鼠标离开
mouseup鼠标弹起

表单事件

reset表单重置
submit表单提交

其他事件

change下拉列表选中项改变，或文本框内容改变
select文本被选定
load页面加载完毕（整个HTML页面中所有的元素全部加载完毕之后发生。）

5.2 注册事件方式

回调函数的特点:由其他程序负责调用该函数

第一种方式，直接在标签中使用事件句柄

<script>
    function sayHello(){
       alert("hello js!");
    }
</script>
<!--以下代码的含义是：将sayHello函数注册到按钮上，等待click事件发生之后，该函数被浏览器调用。我们称这个函数为回调函数。-->
<input type="button" value="hello" onclick="sayHello()"/>

第二种方式，使用js代码完成事件注册

<input type="button" value="hello4" id="mybtn2" />
<script type="text/javascript">
	function doSome(){
		alert("do some!");
	}
// 第一步:先获取这个按钮对象(document是全部小写，内置对象，可以直接用，document就代表整个HTML页面)
var btnObj = document.getElementById("mybtn");
// 第二步:给按钮对象的onclick属性赋值
btnObj.onclick = doSome; 
// 注意:别加小括号. btnObj.onclick = doSome();这是错误的写法.
// 这行代码的含义是,将回调函数doSome注册到click事件上.
</script>

第三种注册方式，使用匿名函数

var mybtn1 = document.getElementById("mybtn");
mybtn1.onclick = function(){ // 匿名函数,这个匿名函数也是一个回调函数.
    alert("test.........."); // 这个函数在页面打开的时候只是注册上,不会被调用,在click事件发生之后才会调用.
}

将其合并

document.getElementById("mybtn").onclick = function(){
   alert("test22222222.........");
}

5.3 代码执行顺序

<script type="text/javascript">
    // 第一步:根据id获取节点对象
    var btn = document.getElementById("btn");
	// 返回null(因为代码执行到此处的时候id="btn"的元素还没有加载到内存)

    // 第二步:给节点对象绑定事件
    btn.onclick = function(){
        alert("hello js");
    }
</script>

<input type="button" value="hello" id="btn" />

执行错误，返回了null，因为还未获取到id元素，
所以我们添加上面的一个函数load()，页面加载完的时候才会发生

<!-- load事件什么时候发生？页面全部元素加载完毕之后才会发生。-->
<body onload="ready()">
    <script type="text/javascript">
    function ready(){
       var btn = document.getElementById("btn");
       btn.onclick = function(){
        alert("hello js");
       }
    }
    </script>
    <input type="button" value="hello" id="btn" />
</body>

<body onload="ready()">
//等同于
//需要写在script内
window.onload=ready;
//如下
<body>
    <script type="text/javascript">
    function ready(){
        window.onload=ready;
       var btn = document.getElementById("btn");
       btn.onclick = function(){
        alert("hello js");
       }
    }
    </script>
    <input type="button" value="hello" id="btn" />
</body>

总结

<script type="text/javascript">
	// 页面加载的过程中,将a函数注册给了load事件
	// 页面加载完毕之后,load事件发生了,此时执行回调函数a
	// 回调函数a执行的过程中,把b函数注册给了id="btn"的click事件
	// 当id="btn"的节点发生click事件之后,b函数被调用并执行.
	window.onload = function(){ // 这个回调函数叫做a
		document.getElementById("btn").onclick = function(){ // 这个回调函数叫做b
			alert("hello js..........");
		}
	}
</script>

<input type="button" value="hello" id="btn" />

总结模板

<script>
    window.onload = function(){
        document.getElementById("id属性").onclick = function(){
            //获得属性后 利用属性执行函数
        }
    }
</script>

<input type="button" value="框中的值" id="id属性" />

5.4 设置节点的属性

通过点击一个按钮狂，将其变为复选框

<script type="text/javascript">
	window.onload = function(){
		document.getElementById("btn").onclick = function(){
			var mytext = document.getElementById("mytext");
			// 一个节点对象中只要有的属性都可以"."
			mytext.type = "checkbox";
		}
	}
</script>

<input type="text" id="mytext"/>
<input type="button" value="将文本框修改为复选框" id="btn"/>

5.5 捕捉回车键

回车键的键值是13
ESC键的键值是27
按钮键是onclick
而回车键onkeydown

回调函数的参数可以有，有与没有都会调用回调函数

usernameElt.onkeydown = function(a, b, c){
	// 获取键值
	 alert(a); // [object KeyboardEvent]
	// alert(b);
	// alert(c);
}

回车键摁下，浏览器会new一个对象，用函数接收当前发生的事件，用当前事件调用属性获取值

usernameElt.onkeydown = function(event){
    // 获取键值
    // 对于“键盘事件对象"来说,都有keyCode属性用来获取键值.
    alert(event.keyCode);
}

如果捕获回车键，需要在事件函数中判断是否为键值

usernameElt.onkeydown = function(event){
  if(event.keyCode === 13){
	  alert("正在进行验证....");
  }
}

5.6 JS运算符

执行表达式，但不返回任何结果

javascript:void(0)其中javascript:作用是告诉浏览器后面是一段JS代码。

以下程序的javascript:是不能省略的

<a href="javascript:void(0)" onclick="window.alert('test code')">
	既保留住超链接的样式，同时用户点击该超链接的时候执行一段JS代码，但页面还不能跳转。
</a>

void()这个小括号当中必须有表达式，且是数字几都可以

href=" " 默认空字符串或者是null或者false都是会跳转的，需要前面加个js标识

5.7 JS的控制语句

java数组的定义与使用

int[] arr = {1,2,3,4,5,6};
int[] arr2 = new int[5]; // 等同于：int[] arr2 = {0,0,0,0,0};
String[] arr3 = {"a","b","c"};
String[] arr4 = new String[3]; // 等同于：String[] arr4 = {null,null,null};

javascript中是定义为var，且类型可以不一致，可以不定义范围有多大，可自扩容

// 创建JS数组
var arr = [false,true,1,2,"abc",3.14]; // JS中数组中元素的类型随意.元素的个数随意.
// 遍历数组
for(var i = 0; i < arr.length; i++){
   alert(arr[i]);
}

对比以上代码的不同，可以增加一个与java不同的结构for in

5.7.1 for in结构

区分java中的for each结构，for each结构中是数组元素，for in是数组下标

// for..in
for(var i in arr){
   //alert(i);
   alert(arr[i]);
}

for in结构还可以遍历对象属性

// for..in语句可以遍历对象的属性
User = function(username,password){
   this.username = username;
   this.password = password;
}
var u = new User("张三", "444");
alert(u.username + "," + u.password);
alert(u["username"] + "," + u["password"]); // 另一种调用方式

for(var shuXingMing in u){
   //alert(shuXingMing) 输出的是username和password
   //alert(typeof shuXingMing) // shuXingMing是一个字符串
   alert(u[shuXingMing]);//不用加双引号
}

5.7.2 with结构

with语句的调用先放在()内，在里面调用属性即可

with(u){
   alert(username + "," + password);
}

06 DOM

DOM：Document Object Model（文档对象模型：对网页当中的节点进行增删改的过程。）HTML文档被当做一棵DOM树来看待。

var domObj = document.getElementById("id");

DOM和BOM的区别：

BOM的顶级对象是：window
DOM的顶级对象是：document
实际上BOM是包括DOM的！

函数模板
通过点击按钮框绑定一个事件
获取事件id的事件，在这个事件中获取单机按钮框的事件

window.onload = function(){
	var xx = document.getElementById("id属性值");
    xx.onclick = function(){
    }
}

而且document.write(“输出语句”);
相当于java的system.out.println();

6.1 文本框value

页面加载执行回调函数
回调函数获取id事件
通过id事件绑定单击按钮执行函数

1.通过点击按钮框获取value值

<script type="text/javascript">
window.onload = function(){
  var btnElt = document.getElementById("btn");
  btnElt.onclick = function(){
	  /*
	  // 获取username节点
	  var usernameElt = document.getElementById("username");
	  var username = usernameElt.value;
	  alert(username);
	  */
	 // alert(document.getElementById("username").value);

 // 可以修改它的value
 document.getElementById("username").value = "zhangsan";
  }
}
</script>

<input type="text" id="username" />
<input type="button" value="获取文本框的value" id="btn"/>

2.将第一个文本框中的value赋值到第二个文本框上

<script type="text/javascript">
	window.onload = function(){
		document.getElementById("setBtn").onclick = function(){
			document.getElementById("username2").value = document.getElementById("username1").value;
		}
	}
</script>


<input type="text" id="username1" />
<br>
<input type="text" id="username2" />
<br>
<input type="button" value="将第一个文本框中的value赋值到第二个文本框上" id="setBtn" />

3.失去焦点对象获取value值，通过this指针

<!--blur事件：失去焦点事件-->
<!--以下代码中的this代表的是当前input节点对象,this.value就是这个节点对象的value属性。-->
<input type="text" onblur="alert(this.value)" />

6.2 inner HTML和innerText属性

inner HTML和innerText是属性不是方法

相同点：

都是设置元素内部的内容。

不同点：

innerHTML会把后面的“字符串”当做一段HTML代码解释并执行。
innerText，即使后面是一段HTML代码，也只是将其当做普通的字符串来看待

<head>
	<meta charset="utf-8">
	<title>DOM编程-innerHTML和innerText操作div和span</title>
	<style type="text/css">
		#div1{
			background-color: aquamarine;
			width: 300px;
			height: 300px;
			border: 1px black solid;
			position: absolute;
			top: 100px;
			left: 100px;
		}
	</style>
</head>
<body>
    <script type="text/javascript">
        window.onload = function(){
            var btn = document.getElementById("btn");
            btn.onclick = function(){
                // 设置div的内容
                // 第一步:获取div对象
                var divElt = document.getElementById("div1");
                // 第二步:使用innerHTML属性来设置元素内部的内容
                // divElt.innerHTML = "fjdkslajfkdlsajkfldsjaklfds";
                // divElt.innerHTML = "<font color='red'>用户名不能为空！</font>";
                divElt.innerText = "<font color='red'>用户名不能为空！</font>";
            }
        }
    </script>
	<input type="button" value="设置div中的内容" id="btn"/>
	<div id="div1"></div>
</body>

6.3 正则表达式

正则表达式（Regular Expression）：主要用在字符串格式匹配方面

6.3.1 常用正则表达式符号

符号	功能
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

6.3.2 常用限定符符号

符号	功能
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

6.3.3 常用的反义代码

符号	功能
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

正则表达式当中的小括号()优先级较高。
- [1-9] 表示1到9的任意1个数字（次数是1次。）
- [A-Za-z0-9] 表示A-Z、a-z、0-9中的任意1个字符
- [A-Za-z0-9-] 表示A-Z、a-z、0-9、- ，以上所有字符中的任意1个字符
简单的正则表达式要会写
- QQ号的正则表达式：
```
^ [1-9][0-9]{4,}$
```
- email正则：^\w+([-+.]\w+)@\w+([-.]\w+).\w+([-.]\w+)*$

6.3.4 创建表达式对象以及调用方式

创建方式：

第一种创建方式：
var regExp = /正则表达式/flags;
第二种创建方式:使用内置支持类RegExp
var regExp = new RegExp(“正则表达式”,“flags”);

关于flag后面的参数：

g：全局匹配
i：忽略大小写
m：多行搜索（ES规范制定之后才支持m）
- 当前面是正则表达式的时候，m不能用
- 只有前面是普通字符串的时候，m才可以使用

调用方式：

正则表达式对象的test()方法

true / false = 正则表达式对象.test(用户填写的字符串);

true : 字符串格式匹配成功
false: 字符串格式匹配失败

6.3.5 验证邮箱格式

1.代码示例验证邮箱是否正确
光标如果回去需要将验证正确与否剔除

<body>

<script type="text/javascript">
window.onload = function(){
	   // 给按钮绑定click
	   document.getElementById("btn").onclick = function(){
		   var email = document.getElementById("email").value;
		   var emailRegExp = /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;
		   var ok = emailRegExp.test(email);
		   if(ok){
				//合法
				document.getElementById("emailError").innerText = "邮箱地址合法";
		   }else{
			   // 不合法
			   document.getElementById("emailError").innerText = "邮箱地址不合法";
		   }
	   }
	   // 给文本框绑定focus
	   document.getElementById("email").onfocus = function(){
		   document.getElementById("emailError").innerText = "";
	   }
   }


</script>

<input type="text" id="email" />
	<span id="emailError" style="color: red; font-size: 12px;"></span>
	<br>
<input type="button" value="验证邮箱" id="btn" />

</body>

输入邮箱验证成功

如果光标回去文本框需要清除右边那个提示，则需要绑定其他

// 给文本框绑定focus
document.getElementById("email").onfocus = function(){
	document.getElementById("emailError").innerText = "";
}

6.3.6扩展字符串trim函数

去除字符串的前后空白trim

<body>
	<script type="text/javascript">	
		window.onload = function(){
			document.getElementById("btn").onclick = function(){
				// 获取用户名
				var username = document.getElementById("username").value;
				// 去除前后空白
				username = username.trim();
				// 测试
				alert("--->" + username + "<----");
			}
		}
	</script>
	<input type="text" id="username" />
	<input type="button" value="获取用户名" id="btn" />
</body>

低版本的IE浏览器不支持字符串的trim()函数,
解决办法：对String类扩展一个全新的trim()函数，重写覆盖新的tim函数，在trim函数中写正则表达式

String.prototype.trim = function(){
	// 去除当前字符串的前后空白
	// 在当前的方法中的this代表的就是当前字符串.
	//return this.replace(/^\s+/, "").replace(/\s+$/, "");
	return this.replace(/^\s+|\s+$/g, "");
}

return this.replace(/^\s+/, "").replace(/\s+$/, "");

这行代码第一个replace是前空格字符串，后一个replace是后空格字符串，
/ 字符串/ ，^是开头，$是结尾，\s是空白字符串，+1个到多个字符串。

prototype可以扩展属性

6.4 表单验证

需求：
（1）用户名不能为空
（2）用户名必须在6-14位之间
（3）用户名只能有数字和字母组成，不能含有其它符号（正则表达式）
（4）密码和确认密码一致，邮箱地址合法。
（5）统一失去焦点验证
（6）错误提示信息统一在span标签中提示（不能用div，div会换行）并且要求字体12号，红色。
（7）文本框再次获得焦点后，清空错误提示信息，如果文本框中数据不合法要求清空文本框的value
（8）最终表单中所有项均合法方可提交

书写的页面表单的html：

<!--这个表单提交应该使用post，这里为了检测，所以使用get。-->
<!-- <form id="userForm" action="http://localhost:8080/jd/save" method="get"> -->
<form id="userForm" method="get">
	用户名<input type="text" name="username" id="username"/>
    	<span id="usernameError"></span><br>
	密码<input type="text" name="userpwd" id="userpwd"/><br>
	确认密码<input type="text" id="userpwd2" />
    	<span id="pwdError"></span><br>
	邮箱<input type="text" name="email" id="email" />
    	<span id="emailError"></span><br>
	<!-- <input type="submit" value="注册" /> -->
	<input type="button" value="注册" id="submitBtn"/>
	<input type="reset" value="重置" />
</form>

写后面表单的错误显示，加一个css样式

<style type="text/css">
	span {
		color: red;
		font-size: 12px;
	}
</style>

书写一个js表单事件判断

其中的代码注意事项

判断username是否为空，可以在if语句中用username，或者是长度，或者直接与空字符串进行比较
获得焦点事件onfocus，如果显示错误，光标回去的时候要自动清除错误字体

判断是否密码一致

用确认密码的句柄，去判断获取对象之后在内容中也获取密码的框，两者进行比较value。相同与否影响后面的span标签提示

// 获取密码错误提示的span标签
var pwdErrorSpan = document.getElementById("pwdError");
// 获取确认密码框对象
var userpwd2Elt = document.getElementById("userpwd2");
// 绑定blur事件
userpwd2Elt.onblur = function(){
   // 获取密码和确认密码
   var userpwdElt = document.getElementById("userpwd");
   var userpwd = userpwdElt.value;
   var userpwd2 = userpwd2Elt.value;
   if(userpwd != userpwd2){
	   // 密码不一致
	   pwdErrorSpan.innerText = "密码不一致";
   }else{
	   // 密码一致
   }
}

绑定focus也相同，不合法之后回去要清除显示的错误

// 绑定focus事件
userpwd2Elt.onfocus = function(){
   if(pwdErrorSpan.innerText != ""){
	   userpwd2Elt.value = "";
   }
   pwdErrorSpan.innerText = "";
}

邮箱同理

逻辑判断：
在提交按钮的情况中，如果都不合法，点击提交还是会提交过去没有审核。所以此处用button的类型按钮，在该按钮中书写js代码

获取表单，通过submit函数提交

<!-- <input type="submit" value="注册" /> -->
<input type="button" value="注册" id="submitBtn"/>

通过普通按钮提交表单，并且完善表单的功能

<!-- <form id="userForm" action="http://localhost:8080/jd/save" method="get"> -->
<form id="userForm" method="get">

在提交表单的js代码中可以这样书写，后面都没有错误的时候提交

// 当所有表单项都是合法的时候,提交表单
if(usernameErrorSpan.innerText == "" && pwdErrorSpan.innerText == "" && emailSpan.innerText == ""){
       // 获取表单对象
       var userFormElt = document.getElementById("userForm");
       // 可以在这里设置action,也可以不在这里.
       userFormElt.action = "http://localhost:8080/jd/save";
       // 提交表单
       userFormElt.submit();
	}

但是如果都不填写后面也没有错误，会自动成功提交空的，所以要在前面添加代码
此处前面不用加on，是代码自动执行，先获得焦点focus，在blur失去焦点的判断

// 触发username的blur userpwd2的blur email的blur
// 不需要人工操作,使用纯JS代码触发事件.
usernameElt.focus();
usernameElt.blur();

userpwd2Elt.focus();
userpwd2Elt.blur();

emailElt.focus();
emailElt.blur();

完整代码演示：

<script type="text/javascript">
window.onload = function(){
	   // 获取username的span标签
	   var usernameErrorSpan = document.getElementById("usernameError");
	   // 给用户名文本框绑定blur事件
	   var usernameElt = document.getElementById("username");
	   usernameElt.onblur = function(){
		   // 获取用户名
		   var username = usernameElt.value;
		   // 去除前后空白
		   username = username.trim();
		   // 判断用户名是否为空
		   /*
		   if(username){
			   // 代表username不是空字符串
			   alert("username = " + username);
		   }else{
			   // 代表username是空字符串
			   alert("username是空字符串");
		   }
		   */
		   // if(username.length == 0){}
		   if(username === ""){
			   // 用户名为空
			   usernameErrorSpan.innerText = "用户名不能为空";
		   }else{
			   // 用户名不为空
			   // 继续判断长度[6-14]
			   if(username.length < 6 || username.length > 14){
				   // 用户名长度非法
				   usernameErrorSpan.innerText = "用户名长度必须在[6-14]之间";
			   }else{
				   // 用户名长度合法
				   // 继续判断是否含有特殊符号
				   var regExp = /^[A-Za-z0-9]+$/;
				   var ok = regExp.test(username);
				   if(ok){
					   // 用户名最终合法
				   }else{
					   // 用户名中含有特殊符号
					   usernameErrorSpan.innerText = "用户名只能由数字和字母组成";
				   }
			   }
		   }
	   }   
   // 给username这个文本框绑定获得焦点事件
   usernameElt.onfocus = function(){
	   // 清空非法的value
	   if(usernameErrorSpan.innerText != ""){
		   usernameElt.value = "";   
	   }
	   // 清空span
	   usernameErrorSpan.innerText = "";
   }
   
   // 获取密码错误提示的span标签
   var pwdErrorSpan = document.getElementById("pwdError");
   // 获取确认密码框对象
   var userpwd2Elt = document.getElementById("userpwd2");
   // 绑定blur事件
   userpwd2Elt.onblur = function(){
	   // 获取密码和确认密码
	   var userpwdElt = document.getElementById("userpwd");
	   var userpwd = userpwdElt.value;
	   var userpwd2 = userpwd2Elt.value;
	   if(userpwd != userpwd2){
		   // 密码不一致
		   pwdErrorSpan.innerText = "密码不一致";
	   }else{
		   // 密码一致
	   }
   }
   
   // 绑定focus事件
   userpwd2Elt.onfocus = function(){
	   if(pwdErrorSpan.innerText != ""){
		   userpwd2Elt.value = "";
	   }
	   pwdErrorSpan.innerText = "";
   }
   
   // 获取email的span
   var emailSpan = document.getElementById("emailError");
   // 给email绑定blur事件
   var emailElt = document.getElementById("email");
   emailElt.onblur = function(){
	   // 获取email
	   var email = emailElt.value;
	   // 编写email的正则
	   var emailRegExp = /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/;
	   var ok = emailRegExp.test(email);
	   if(ok){
		   // 合法
	   }else{
		   // 不合法
		   emailSpan.innerText = "邮箱地址不合法";
	   }
   }
   
   // 给emailElt绑定focus
   emailElt.onfocus = function(){
	   if(emailSpan.innerText != ""){
		   emailElt.value = "";
	   }
	   emailSpan.innerText = "";
   }
   
   // 给提交按钮绑定鼠标单击事件
   var submitBtnElt = document.getElementById("submitBtn");
   submitBtn.onclick = function(){
	   // 触发username的blur userpwd2的blur email的blur
	   // 不需要人工操作,使用纯JS代码触发事件.
	   usernameElt.focus();
	   usernameElt.blur();
	   
	   userpwd2Elt.focus();
	   userpwd2Elt.blur();
	   
	   emailElt.focus();
	   emailElt.blur();
	   
	   // 当所有表单项都是合法的时候,提交表单
	   if(usernameErrorSpan.innerText == "" && pwdErrorSpan.innerText == "" && emailSpan.innerText == ""){
		   // 获取表单对象
		   var userFormElt = document.getElementById("userForm");
		   // 可以在这里设置action,也可以不在这里.
		   userFormElt.action = "http://localhost:8080/jd/save";
		   // 提交表单
		   userFormElt.submit();
	   }
   }
}
</script>

6.5 复选框的全选和取消全选

书写一个html的页面
将所有的框都书写成相同的name属性值

<input type="checkbox" id="firstChk"/><Br>
<input type="checkbox" name="aihao" value="smoke" />抽烟<Br>
<input type="checkbox" name="aihao" value="drink" />喝酒<Br>
<input type="checkbox" name="aihao" value="tt" />烫头<Br>

在添加一个js的逻辑代码

form表单中的checked属性是勾选则为true，如果没勾选则为false
通过document.getElementsByName(“aihao”);获取按钮狂中相同的name属性存储在一个数组中
通过判定，如果勾选复选框，将其一一弄为true，同理为false

window.onload = function(){
	var firstChk = document.getElementById("firstChk");
	firstChk.onclick = function(){
		// 获取第一个复选框的选中状态(复选框对象checkbox对象)
		//alert(firstChk.checked);
		// 根据name获取所有元素
		var aihaos = document.getElementsByName("aihao");
		if(firstChk.checked){
			// 全选
			for(var i = 0; i < aihaos.length; i++){
				aihaos[i].checked = true;
			}
		}else{
			// 取消全选
			for(var i = 0; i < aihaos.length; i++){
				aihaos[i].checked = false;
			}
		}
	}
}

优化代码的格式，将其与复选框相同即可

window.onload = function(){
    var firstChk = document.getElementById("firstChk");
    firstChk.onclick = function(){
        var aihaos = document.getElementsByName("aihao");
        for(var i = 0; i < aihaos.length; i++){
            aihaos[i].checked = firstChk.checked;
        }
	}
}

添加额外的功能：如果复选框的子框都选上了，则复选框都选上；

代码逻辑：页面加载的时候，将其所有子框进行遍历绑定一个鼠标单机按钮，如果单机一个子框，在其功能中再将其遍历，判断是否为总数都单击了

 window.onload = function(){	
    var firstChk = document.getElementById("firstChk");
        firstChk.onclick = function(){
            var aihaos = document.getElementsByName("aihao");
            for(var i = 0; i < aihaos.length; i++){
                aihaos[i].checked = firstChk.checked;
            }
        }
     
     
    var all = aihaos.length;
    for(var i = 0; i < aihaos.length; i++){
        aihaos[i].onclick = function(){//绑定回调函数，并不是执行
            var checkedCount = 0;
            // 总数量和选中的数量相等的时候,第一个复选框选中.
            for(var i = 0; i < aihaos.length; i++){
                if(aihaos[i].checked){
                    checkedCount++;
                }
            }
            firstChk.checked = (all == checkedCount);
            /*
            if(all == checkedCount){
                firstChk.checked = true;
            }else{
                firstChk.checked = false;
            }
            */
        }
    }
}

完整代码演示：

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>复选框的全选和取消全选</title>
	</head>
	<body>
		<script type="text/javascript">
			/*
			window.onload = function(){
                var firstChk = document.getElementById("firstChk");
                firstChk.onclick = function(){
                    // 获取第一个复选框的选中状态(复选框对象checkbox对象)
                    //alert(firstChk.checked);
                    // 根据name获取所有元素
                    var aihaos = document.getElementsByName("aihao");
                    if(firstChk.checked){
                        // 全选
                        for(var i = 0; i < aihaos.length; i++){
                            aihaos[i].checked = true;
                        }
                    }else{
                        // 取消全选
                        for(var i = 0; i < aihaos.length; i++){
                            aihaos[i].checked = false;
                        }
                    }
                }
			}
			*/
		window.onload = function(){
			var aihaos = document.getElementsByName("aihao");
			var firstChk = document.getElementById("firstChk");
			firstChk.onclick = function(){
				for(var i = 0; i < aihaos.length; i++){
					aihaos[i].checked = firstChk.checked;
				}
			}
			// 对以上数组进行遍历
			var all = aihaos.length;
			for(var i = 0; i < aihaos.length; i++){
				aihaos[i].onclick = function(){
					var checkedCount = 0;
					// 总数量和选中的数量相等的时候,第一个复选框选中.
					for(var i = 0; i < aihaos.length; i++){
						if(aihaos[i].checked){
							checkedCount++;
						}
					}
					firstChk.checked = (all == checkedCount);
					/*
					if(all == checkedCount){
						firstChk.checked = true;
					}else{
						firstChk.checked = false;
					}
					*/
				}
			}
		}
	</script>
	<input type="checkbox" id="firstChk"/><Br>
    <input type="checkbox" name="aihao" value="smoke" />抽烟<Br>
    <input type="checkbox" name="aihao" value="drink" />喝酒<Br>
    <input type="checkbox" name="aihao" value="tt" />烫头<Br>	
</body>
</html>

6.6 获取下拉列表选项中的value

通过onchange的事件获取当前下拉列表的值，this代表当前

<select onchange="alert(this.value)">
	<option value="">--请选择省份--</option>
	<option value="001">河北省</option>
	<option value="002">河南省</option>
	<option value="003">山东省</option>
	<option value="004">山西省</option>
</select>

可以通过书写js代码。换一种形式

<script type="text/javascript">
	window.onload = function(){
		var provinceListElt = document.getElementById("provinceList");
		provinceListElt.onchange = function(){
			// 获取选中项的value
			alert(provinceListElt.value);
		}
	}
</script>
<select id="provinceList">
	<option value="">--请选择省份--</option>
	<option value="001">河北省</option>
	<option value="002">河南省</option>
	<option value="003">山东省</option>
	<option value="004">山西省</option>
</select>

6.7 内置支持类

6.7.1 获取日期/日期Date

var nowTime = new Date();
document.write(nowTime);

不符合当前的日期格式视角
转换成具有本地语言环境的日期格式

nowTime = nowTime.toLocaleString();

如果需要自已整合一个日期格式可以这样写

获取年份信息getFullYear();
获取月份日期getMonth();
获取当日信息getDate();
获取当前系统的毫秒数(从1970年1月1日 00:00:00 000到当前系统时间的总毫秒数)getTime();

// 当以上格式不是自己想要的,可以通过日期获取年月日等信息,自定制日期格式.
var t = new Date();
var year = t.getFullYear(); // 返回年信息,以全格式返回.
var month = t.getMonth(); // 月份是:0-11
// var dayOfWeek = t.getDay(); // 获取的一周的第几天(0-6)
var day = t.getDate(); // 获取日信息.
document.write(year + "年" + (month+1) + "月" + day + "日");

通过结合按钮框，一点击就显示有系统时间

系统开始时间setInterval(“函数名”, 间隔毫秒时间数)
终止系统时间，通过传输开始执行的数据clearInterval(传输开始执行的数据)

<script type="text/javascript">
	function displayTime(){
		var time = new Date(); //新建一个date对象
		var strTime = time.toLocaleString(); // 转换为字符串
		document.getElementById("timeDiv").innerHTML = strTime; //显示html格式
	}
    // 每隔1秒调用displayTime()函数
    function start(){
        // 从这行代码执行结束开始,则会不间断的,每隔1000毫秒调用一次displayTime()函数.
        v = window.setInterval("displayTime()", 1000);	
    }
    function stop(){
        window.clearInterval(v);
    }
</script>

<input type="button" value="显示系统时间" onclick="start();"/>
<input type="button" value="系统时间停止" onclick="stop();" />
<div id="timeDiv"></div>

6.7.2 数组内置类

数组定义用中括号，而java的数组定义用{}
数组类型随意
数组可越界扩容

// 创建长度为0的数组
var arr = [];
alert(arr.length);

// 数据类型随意
var arr2 = [1,2,3,false,"abc",3.14];
alert(arr2.length);

// 下标会越界吗
arr2[7] = "test"; // 自动扩容.

document.write("<br>");

// 遍历
for(var i = 0; i < arr2.length; i++){
	document.write(arr2[i] + "<br>");
}

另一种创建数组对象的方式

var a = new Array();
alert(a.length); // 0

var a2 = new Array(3); // 3表示长度.
alert(a2.length);

var a3 = new Array(3,2);
alert(a3.length); // 2

数组的相关方法

连接字符串join(“连接符”);
数组末尾添加元素push(压栈);
数组末尾弹出元素pop();
反转数组reverse();

var a = [1,2,3,9];
var str = a.join("-");
alert(str); // "1-2-3-9"

// 在数组的末尾添加一个元素(数组长度+1)
a.push(10);
alert(a.join("-"));

// 将数组末尾的元素弹出(数组长度-1)
var endElt = a.pop();
alert(endElt);
alert(a.join("-"));

// 注意:JS中的数组可以自动模拟栈数据结构:后进先出,先进后出原则.
// push压栈
// pop弹栈

// 反转数组.
a.reverse();
alert(a.join("="));

07 BOM

BOM编程中，window对象是顶级对象，代表浏览器窗口

7.1 open与close

window有open和close方法，可以开启窗口和关闭窗口

打开window.open();
关闭window.close();只能关闭open打开的窗口

<input type="button" value="开启百度(新窗口)" onclick="window.open('http://www.baidu.com');" />
<input type="button" value="开启百度(当前窗口)" onclick="window.open('http://www.baidu.com', '_self');" />
<input type="button" value="开启百度(新窗口)" onclick="window.open('http://www.baidu.com', '_blank');" />
<input type="button" value="开启百度(父窗口)" onclick="window.open('http://www.baidu.com', '_parent');" />
<input type="button" value="开启百度(顶级窗口)" onclick="window.open('http://www.baidu.com', '_top');" />

<input type="button" value="打开表单验证"  onclick="window.open('002-open.html')"/>

当前窗口与顶级窗口

覆盖整个页面的窗口只有一个可以理解为顶级窗口

将当前窗口设置为顶级窗口代码演示

if(window.top != window.self){
	//window.top = window.self;
	window.top.location = window.self.location;
}

7.2 弹出确认框

消息框window.alert(‘消息框!’)"
确认框window.confirm(“确认框”);

弹出消息框，之前都有用到

<input type="button" value="弹出消息框" onclick="window.alert('消息框!')" />

删除消息的确认框

<script type="text/javascript">
	function del(){
		/*
		var ok = window.confirm("亲，确认删除数据吗？");
		//alert(ok);
		if(ok){
			alert("delete data ....");
		}
		*/
		if(window.confirm("亲，确认删除数据吗？")){
			alert("delete data ....");
		}
	}
</script>
<input type="button" value="弹出确认框(删除)" onclick="del();" />

7.3 历史记录

历史纪录的后退window.history.back()或者是window.history.go(-1)
历史纪录的前进window.history.go(1)

<input type="button" value="后退" onclick="window.history.back()" />
<input type="button" value="后退" onclick="window.history.go(-1)" />

7.4 设置地址栏的url

var xx = window.location;
xx.href = "http://网址";

或者window.location.href = “http://网址”;
或者window.location = “http://网址”;
或者document.location.href = “http://网址”;同理href可以省略

总结：有哪些方法可以通过浏览器往服务器发请求

表单form的提交。
超链接。

<a href="http://localhost:8080/oa/save?username=zhangsan&password=123">
    用户只能点击这个超链接
</a>

document.location
window.location
window.open(“url”)
直接在浏览器地址栏上输入URL，然后回车。（这个也可以手动输入，提交数据也可以成为动态的。）
以上所有的请求方式均可以携带数据给服务器，只有通过表单提交的数据才是动态的

08 JSON

JavaScript Object Notation（JavaScript对象标记），简称JSON。(数据交换格式)。JSON是一种标准的轻量级的数据交换格式。特点是：体积小，易解析
JSON主要的作用是：一种标准的数据交换格式。（目前非常流行，90%以上的系统，系统A与系统B交换数据的话，都是采用JSON。）
在实际的开发中有两种数据交换格式，使用最多，其一是JSON，另一个是XML。XML体积较大，解析麻烦，但是有其优点是：语法严谨。（通常银行相关的系统之间进行数据交换的话会使用XML。）

8.1 代码比较

两个数据要交换可以用json或者xml，通过与java交换
对比一下数据的轻量级

// 创建JSON对象(JSON也可以称为无类型对象。轻量级，轻巧。体积小。易解析。)
var studentObj = {
	"sno" : "110",
	"sname" : "张三",
	"sex" : "男"
};

// 访问JSON对象的属性
alert(studentObj.sno + "," + studentObj.sname + "," + studentObj.sex);

也可以进行数组的遍历

// JSON数组
var students = [
	{"sno":"110","sname":"张三","sex":"男"},
	{"sno":"120","sname":"李四","sex":"男"},
	{"sno":"130","sname":"王五","sex":"男"}
];

// 遍历
for(var i = 0; i < students.length; i++){
	var stuObj = students[i];
	alert(stuObj.sno + "," + stuObj.sname + "," + stuObj.sex);
}

所以json的代码格式是：

var jsonObj = {
	"属性名" : 属性值,
	"属性名" : 属性值,
	"属性名" : 属性值,
	"属性名" : 属性值,
	....
};

对比：
之前没有使用JSON的时候,定义类,创建对象,访问对象的属性.

Student = function(sno,sname,sex){
	this.sno = sno;
	this.sname = sname;
	this.sex = sex;
}
var stu = new Student("111","李四","男");
alert(stu.sno + "," + stu.sname + "," + stu.sex);

8.2 JSON对象

通过键值对进行一一书写
可以json嵌套json数据

var user = {
	"usercode" : 110,
	"username" : "张三",
	"sex" : true,
	"address" : {
		"city" : "北京",
		"street" : "大兴区",
		"zipcode" : "12212121",
	},
	"aihao" : ["smoke","drink","tt"]
};

// 访问人名以及居住的城市
alert(user.username + "居住在" + user.address.city);

代码示列：
请自行设计JSON格式的数据，这个JSON格式的数据可以描述整个班级中每一个学生的信息，以及总人数信息。

var jsonData = {
	"total" : 3,
	"students" : [
		{"name":"zhangsan","birth":"1980-10-20"},
		{"name":"lisi","birth":"1981-10-20"},
		{"name":"wangwu","birth":"1982-10-20"}
	]
};

记住格式符号不要错乱，特别是;

8.3 eval函数

通过eval赖连接前后端的函数
功能：将字符串当做一段JS代码解释并执行
例如：window.eval(“var i = 100;”);

主要在实战中

java连接数据库,查询数据之后,将数据在java程序中拼接成JSON格式的“字符串”,将json格式的字符串响应到浏览器
java响应到浏览器上的仅仅是一个"JSON格式的字符串",还不是一个json对象
可以使用eval函数,将json格式的字符串转换成json对象

var fromJava = "{\"name\":\"zhangsan\",\"password\":\"123\"}"; //这是java程序给发过来的json格式的"字符串"
// 将以上的json格式的字符串转换成json对象
window.eval("var jsonObj = " + fromJava);
// 访问json对象
alert(jsonObj.name + "," + jsonObj.password); // 在前端取数据

用java处理json发过来的字符串对象，\这是转义字符，将其转换成json的对象，在用对象调用属性
js中访问对象属性还可以用这种代码格式

// JS中访问json对象的属性
alert(json.username);

// JS中访问json对象的属性
alert(json["username"]);

8.4 设置table的tbody

将java中的数据展示到table中
表格页面的html格式如下

<input type="button" value="显示员工信息列表" id="displayBtn" />
<h2>员工信息列表</h2>
<hr>
<table border="1px" width="50%">
	<tr>
		<th>员工编号</th>
		<th>员工名字</th>
		<th>员工薪资</th>
	</tr>
	<tbody id="emptbody">
		<!--
		<tr>
			<td>7369</td>
			<td>SMITH</td>
			<td>800</td>
		</tr>
		<tr>
			<td>7369</td>
			<td>SMITH</td>
			<td>800</td>
		</tr>
		<tr>
			<td>7369</td>
			<td>SMITH</td>
			<td>800</td>
		</tr>
		-->
	</tbody>
</table>
总共<span id="count">0</span>条数

本身tbody没有数据，通过点按钮，将json的数据显示到页面上
json的数据如下

// 有这些json数据
var data = {
	"total" : 4,
	"emps" : [
		{"empno":7369,"ename":"SMITH","sal":800.0},
		{"empno":7361,"ename":"SMITH2","sal":1800.0},
		{"empno":7360,"ename":"SMITH3","sal":2800.0},
		{"empno":7362,"ename":"SMITH4","sal":3800.0}
	]
};

通过点击按钮框实现的代码逻辑如下
每循环一次加一个html的页面以及json的数据
数据都加载到tbody中

document.getElementById("emptbody").innerHTML = html;
document.getElementById("count").innerHTML = data.total;

完整代码如图

// 希望把数据展示到table当中.
window.onload = function(){
	var displayBtnElt = document.getElementById("displayBtn");
	displayBtnElt.onclick = function(){
		var emps = data.emps;
		var html = "";
		for(var i = 0; i < emps.length; i++){
			var emp = emps[i];
			html += "<tr>";
			html += "<td>"+emp.empno+"</td>";
			html += "<td>"+emp.ename+"</td>";
			html += "<td>"+emp.sal+"</td>";
			html += "</tr>";
		}
		document.getElementById("emptbody").innerHTML = html;
		document.getElementById("count").innerHTML = data.total;
	}
}

8.5 面试题

在JS当中：[]和{}有什么区别

[] 是数组
{} 是JSON

java中的数组：int[] arr = {1,2,3,4,5};
JS中的数组：var arr = [1,2,3,4,5];
JSON：var jsonObj = {“email” : “zhangsan@123.com”,“age”:25};

胖虎不秃头

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaScript——基于原型编程、多范式的动态脚本语言

JS函数类似Java中的方法Java中定义方法的格式是[修饰符列表]返回值类型方法名(形式参数列表){方法体;}...}JS是一种弱类型，JS中的函数不需要指定返回值类型，返回什么类型都行函数的定义格式是//第一种方式function函数名(形式参数列表){函数体;}//第二种方式函数名=function(形式参数列表){函数体;}例如函数//a和b都是局部变量,他们都是形参(a和b都是变量名，变量名随意。)}sum(10,20);......
复制链接

扫一扫