01javascript语法规范
<!DOCTYPE html>
<html>
<head>
<title>javascript语法规范</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
<!-- 注意：双引号里不能再有双引号 点击才激发 -->
<button onclick="alert('今天天气很好！');">今天天气很好！</button>
</body>
<script type="text/javascript"> //内部引入
alert("今天天气真好。");
</script>
<script src="../js/01.js"></script> //外部引入
</html>
02初体验
<!DOCTYPE html>
<html>
<head>
<title>02初体验</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script src="../js/01.js"></script> //外部引入写法
</html>
03js的输出方法
<!DOCTYPE html>
<html>
<head>
<title>03js的输出方法</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
<div id="div1"></div>
<div id="div2"></div>
</body>
<script src="../js/02.js"></script>
</html>
/* 输出方式一 alert("我是欧阳勤斌 弹框输出");*/
alert("我是欧阳勤斌------alert('我是欧阳勤斌')");
/* 方式二 console.log("控制台输出法"); */
console.log("我是欧阳勤斌");
/*方式三 console.warn("警告输出！控制台输出"); */
console.warn("警告输出！欧阳勤斌");
/* 方式四 console.error("错误输出！控制台输出");*/
console.error("错误输出！欧阳勤斌");
/* 方式五 prompt("Hello, javascript 欧阳勤斌 弹框输出");*/
prompt("Hello, javascript 欧阳勤斌");
/* 方式六 confirm("Hello, javascript 欧阳勤斌 弹框输出");*/
confirm("Hello, javascript 欧阳勤斌");
/* 方式七 document.write("欧阳勤斌 网页中输出");*/
document.write("欧阳勤斌");
/*document.getElementById("div1").innerHTML = "吧啦吧啦吧啦吧啦";
document.getElementById("div2").innerText = "吧啦吧啦吧啦吧啦"; */
04js注意事项
<!DOCTYPE html>
<html>
<head>
<title>04js注意事项</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script src="../js/04.js"></script>
</html>
/*
1、编写Javascript注意语法规范，一行代码结束后必须在代码最后加上分号（;）
如果不写分号，浏览器会自动添加，但是会消耗一些系统资源；此外，容易加错分号，所以在开发中分号必须要写。
2、在Javascript中是严格区分大小写的
3、javascript中会忽略多个空格和换行
*/
document.write("欧阳勤斌")
document.write("欧阳勤斌")
document.write("欧阳勤斌")
document.write("欧阳勤斌") /* 这样可以输出 */
// document.write("欧阳勤斌")document.write("欧阳勤斌") // 这样就不能输出了。
document.write("欧阳勤斌"); //这样可以输出。正确的输出方式。
//Docunent.write("我是欧阳。"); //这样就不能输出。 在Javascript中是严格区分大小写的
/*
document.write(" //双引号的位置
我是ouyang。
"); //这里报错了。
*/
/*
console.log("
我是ouyang
"); //这样写也会报错。
*/
console.log(
"我是ouyang."
) //这样写就可以。
05js的注释
<!DOCTYPE html>
<html>
<head>
<title>05js的注释</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script src="../js/05.js"></script>
</html>
// 两条斜线－－－ 单行注释。
alert("我是ouyang."); //这是一个弹框。
/*
两条斜线+两个星号表示－－－－ 多行注释 注释内容在两个星号之间。
*/
console.log("我是ouyangqb.");
/*
这是在控制台上显示。
*/
// 单行注释中可以有多行注释,但是必需是写在一行上 /**/
// 单行注释中 可以重复使用单行注释。//1 //2 //3
document.write("我要把名字写在网页上：ouyangqb."); // 输出到网页上/*这样写是可以的*/
/*
多行注释中也可以有单行注释的标志 //也可以写在这里。
*/
06js常量和变量
<!DOCTYPE html>
<html>
<head>
<title>06js常量和变量</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script src="../js/06.js"></script>
</html>
console.log(3+5); /* 数值常量 */
console.log(0.3+0.8);
console.log("a"+"b"); /* 字符串常量 一般用双引号或单引号 引住 */
console.log("56"); //这个是字符串常量。
console.log(true); //布而常量
console.log(false);
//特殊字符常量
console.log("\n"); //回车
//变量
/*
当一个数据的值需要经常改变或不确定时，就应该用变量来表示。
购物和购物车的关系。
定义变量的目的：在内存中分配一块存储空间给变量，方便以后存储数据。
如何定义变量：定义变量（声明变量），任何变量在使用之前，必须先进行定义。
如果定义了多个变量，就会为这多个变量分配不同的存储空间。
var 变量名称。（声明变量）
*/
var name;
var sex;
var age;
// 上面是一种定义变量的方法。
var name,sex,age;
// 这也是一种定义变量的方法。用倒号分开两个变量之间，分号结束。
//变量的赋值 =
var name,sex,age;
name = "ouyangqinbin";
sex = "男";
age = 43;
console.log(name);
console.log(sex);
console.log(age);
07js变量的声明
<!DOCTYPE html>
<html>
<head>
<title>07js变量的声明</title>
<meta http-equiv="content-type" content="text/html;charset=utf-8"/>
</head>
<body>
</body>
<script src="../js/07.js"></script>
</html>
//变量的声明 var 变量名;
var name = "欧阳勤斌", //边定义边初始化
sex = "男",
age = 43;
console.log(name);
console.log(sex);
console.log(age);
// = 是 赋值符号
var name = "欧阳勤斌";
var sex = "男";
var age = 43;
console.log(name);
console.log(sex);
console.log(age);
//另一种变量的声明和赋值方法
var name = "欧阳勤斌";
sex = "男"; //这种是没有声明直接调用的变量
age = 43; //这种是没有声明直接调用的变量 和上面的有不同的。
console.log(name);
console.log(sex);
console.log(age);
//变量第一次赋值，可以称为“初始化”
//先定义 后初始化。
var name,sex,age;
name = "欧阳勤斌";
sex = "男";
age = 43
console.log(name);
console.log(sex);
console.log(age);
//边定义的同时进行初始化
var name = "欧阳继州",sex = "男"; age =13;
console.log(name);
console.log(sex);
console.log(age);
//其他表现形式
var name = name_one = name_two = "欧阳继霖";
console.log(name);
console.log(name_one);
console.log(name_two);
//如果定义后没有初始化。也叫部分初始化
var name,sex = "男",age =43;
//查看变量的值。直接输出就可以。console.log(变量名);
console.log(sex);
alert(sex);
document.write(sex);
//如何改变变量的值。
var sex = "男";
console.log(sex);
sex = "女";
console.log(sex);
//关键字和保留字
//var break do instanceof typeof case else new for 关键字
//class enum extends super 保留字
/*命名一个标识符时需要遵守如下的规则：
1、标识符中可以含有字母、数字、下划线 $符号。
2、标识符不能以数字开头
3、标识符不能是ES中关键字或保留字
4、严格区分大小写，比如name 和 NAME是2个不同的标识符
5、标识符一般都采用驼峰命名法
*/
//正确的命名法。
var name,$sex,name_,age43;
//不正确的命名法。
//var 12name;
08js数据类型
<!DOCTYPE html>
<html>
<head>
<title>08js数据类型</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script>
/*
数据类型分为简单的数据类型和复杂的数据类型
简单的数据类型分为：数值类型、字符类型、布尔类型、undefined(变量未初始化)、null(空类型)
查看 数据的类型 typeof 变量
*/
console.log(typeof 11);
// number 数值类型
console.log(typeof "10");
// string 字符串类型
var number1 = 123, number2 = 1.23;
console.log(typeof number1);
console.log(typeof number2);
//数值类型的最大、最小值。
console.log(Number.MAX_VALUE); //这个是数值的最大值。
console.log(Number.MIN_VALUE); //这个是输出数值的最小值
//无穷大 infinity,如果超过了最大值就会返回该值
console.log(Number.MAX_VALUE+Number.MAX_VALUE);
//无穷小 -infinity,如果超过了最小值就会返回该值
//查看 无穷大和无穷小的类型
console.log(typeof Infinity);
console.log(typeof -Infinity);
//NaN 非法数字(Not A Number)
console.log("中国"-12);
console.log("中国"+12);
//这是的加号(+)是做字符串的拼接。
//Number 类型的注意事项。
var number3 = 100, number4 = 200;
var number5 = 1.23, number6 = 2.56;
console.log(number3+number4);
console.log(number5+number6);
console.log(1.56*2.85); //这里会出现00000001的值。所以我们只要求最小数位就可以了。
//字符串类型
/*字符串类型是由单引号或双引号括起。*/
console.log(typeof a); //这里a是一个未初始化的变量。 所以这个是undefined类型，
console.log(typeof "a");//这里的a是一个字符串类型。
//使用字符串注意事项
var str1 = "hello";
var str2 = "world";
console.log(str1);
console.log(str2);
//查看变量的类型
console.log(typeof str1);
console.log(typeof str2);
//var str3 ='hello world"; // 错误的写法一单一双。 SyntaxError: '' string literal contains an unescaped line break
//var str4 = "hello world';// 错误的写法一双一单。 SyntaxError: "" string literal contains an unescaped line break
//var str5 =""hello" "world""; //错误的写法双中含双。SyntaxError: unexpected token: identifier
//var str6 = ''hello' + 'world''; //错误的写法单中含单。SyntaxError: unexpected token: identifier
//正确写法
//不能是一单一双，必须成对出现
//相同引号不能嵌套，不同引号可以嵌套。
var str3 = "'hello'+'world'";
console.log(str3);
console.log(typeof str3);
var str4 ='"hello"+"world"';
console.log(str4);
//布尔类型
/*布尔类型也被称为逻辑值类型或者真假值类型
布尔类型只能够取真(true)和假(false)两种数值，也代表1和0，实际运算中true = 1,false = 0;
*/
var true1 = true;
console.log(true1); //true
console.log(typeof true1); //boolean
console.log(typeof Boolean(0)); //boolean
console.log(Boolean(0)); //false
console.log(Boolean(1)); //true
console.log(typeof 1); //number
//布尔类型注意 一定是Boolean(常量)
/*
任何非零数值都是true,包括正负无穷大、小，只有0和NaN是false;
任何非空字符串都是true，只有空字符串是false
任何对象都是true 只有null和undefined是false
*/
console.log(Boolean(0)); //false
console.log(Boolean(10)); //true
console.log(Boolean("")); //false
var bool1 = "";
console.log(typeof bool1); //string
console.log(Boolean(" ")); //true
//undefined是Undefined类型的字面量 表示变量未赋值，这种类型只有一种值就是undefined.
var num1;
console.log(num1);
var num2 = undefined;
console.log(num2);
//Null类型是第二个只有一个值的数据类型，这个特殊的值是null;
var stri1 = null;
var stri2 = undefined;
console.log(stri1 == stri2);
console.log(stri1===stri2); //它们的值是相等但是类型是不同。
</script>
</html>
09js数据类型的转化
<!DOCTYPE html>
<html>
<head>
<title>09js数据类型的转化</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script>
//数据类型之间的转换
/*数字类型转换成字符串类型 toString 格式：变量.toString(); */
var num1 = 123;
//数字类型转换成字符串类型
console.log(typeof num1.toString()); //输出类型。
console.log(num1.toString()); //输出成果。
//num1.toString() //转换格式
//布尔类型转换成字符串类型 toString 格式：变量.toString();
var bool1 = true;
console.log(bool1);
console.log(typeof bool1);
var str1 = bool1.toString();
console.log(str1);
console.log(typeof str1);
//注意：null和undefined没有toString()方法，如果强行调用，则会报错。
var str2 = null;
console.log(str2);
//var stri2 = str2.toString(); //不能转换
//console.log(stri2); // 报错了：Uncaught TypeError: Cannot read property 'toString' of null
var str3 = "";
console.log(str3); //空字符串
console.log(typeof str3); //string
var stri3 = str3.toString(); //字符串转换成字符串
console.log(stri3); //空字符串
console.log(typeof stri3); //string
var str4;
console.log(str4); //undefined
//var stri4 = str4.toString(); //报错了：undefined是不能转换成字符串 Uncaught TypeError: Cannot read property 'toString' of undefined
//console.log(stri4);
var str5 = undefined;
console.log(str5);
//var stri5 = str5.toString(); //报错了：undefined是不能转换成字符串 Uncaught TypeError: Cannot read property 'toString' of undefined
//console.log(stri5);
//NaN类型的转换字符串类型
var str6 = NaN;
console.log(str6); //输出：NaN
console.log(typeof str6); //输出类型：number;
var stri6 = str6.toString();
console.log(stri6);
console.log(typeof stri6);
//null和undefined 转换成字符串。 用String()函数转换 格式：String(变量);
var str7 = null;
var stri7 = String(str7);
console.log(stri7);
console.log(typeof stri7);
var str8;
console.log(str8);
var stri8 = String(str8);
console.log(stri8);
console.log(typeof stri8);
//强制转换 +
var name = "欧阳勤斌";
var age = 43;
console.log(name + age);
console.log(typeof (name + age));
//最好用的是 + ""; 加上一个空字符串就好。
var num2 = 245;
console.log(num2+"");
console.log(typeof (num2+""));
var num3 = null,num4 = undefined;
var numb3 = null +"";
var numb4 = undefined +"";
console.log(numb3);
console.log(numb4);
console.log(typeof numb3);
console.log(typeof numb4);
//1、字符串 转 数字 格式：Number(变量)
var str9 = "12345";
var stri9 = Number(str9);
console.log(stri9);
console.log(typeof stri9);
//2、如果字符串中有非数字的内容时，则转换为NaN
var str10 = "150ab";
var stri10 = Number(str10);
console.log(stri10);
console.log(typeof stri10);
var str11 = "ab120";
var stri11 = Number(str11);
console.log(stri11);
console.log(typeof stri11);
//3、如果字符串是一个空串或者是一个全是空格的字符，则转换为0；
var str12 = "";
var stri12 = Number(str12);
console.log(stri12); //0
console.log(typeof stri12); //number
var str13 = " ";
var stri13 = Number(str13);
console.log(stri13); //0
console.log(typeof stri13); //number
//undefined 转换成数字类型
var str14;
console.log(str14);
stri14 = Number(str14); //转换成为NaN
console.log(stri14);
console.log(typeof stri14); //number类型
var str15 = undefined;
var stri15 = Number(str15);
console.log(stri15);
console.log(typeof stri15);
//null 转换为 数字类型
var str16 = null;
var stri16 = Number(str16); //0
console.log(stri16); //输出：0
console.log(typeof stri16); //number
//布尔类型 转换为 数字类型
//布尔类型只有两个值 true 和 false
var str17 = true;
var stri17 = Number(str17);
console.log(stri17);
console.log(typeof stri17);
var str18 = false;
var stri18 = Number(str18);
console.log(stri18);
console.log(typeof stri18);
//parseInt()或parseFloat()可以提取字符串中的有效整数
//parseInt() 提取字符串中的整数。只能提取数字开头的字符串值。
var str19 = "av45bc";
var stri19 = parseInt(str19); //NaN 不能提取字母开头中的数字。
console.log(stri19); //输出:NaN
var str20 = "124abe";
var stri20 = parseInt(str20); //124
console.log(stri20); //输出：124
var str21 = "125.65adbe";
var stri21 = parseInt(str21); //这个提取的是整数。
var strf21 = parseFloat(str21); //这个提取的是小数（浮点数）
console.log(stri21); //输出整数部分 125
console.log(strf21); //输出的是小数 125.65
</script>
</html>
10js运算符操作
<!DOCTYPE html>
<html>
<head>
<title>10js运算符操作</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script>
//页内式
//运算符操作 按照功能划分：算术运算符 位运算符 关系运算符 逻辑运算符。
//按照操作数个数划分：单目运算 双目运算 三目运算。
// + 运算
var num = 100 + 200;
console.log(num);
var numb1 = 100;
var numb2 = 200;
var num1 = numb1 + numb2;
console.log(num1);
// 1、非Number类型的值进行运算时，会将这些值转换为Number然后在运算。
/* 布尔类型 和 数字类型运算 */
var num2 = true + 2; //true 相当于整数的 1 结果是：3
console.log(num2);
var num3 = true + false; //false 相当于整数的 0 结果是：1
var num4 = false + 3; //结果是：3
console.log(num3); //输出是：1
console.log(num4); //输出是：3
/* null 和数字类型运算 */
var numb3 = null;
var num5 = numb3 + 10;
console.log(Number(null)); //输出结果：0
console.log(num5); //输出结果：10
/* 任何数值和NaN作运算结果都是 NaN 这里讲的是数值，不是字符串 */
var numb4 = 200;
var num6 = numb4 + NaN; //结果是：NaN
console.log(num6); //输出是：NaN
var str1 = "ouyangqinbin";
var stri1 = str1+NaN; //结果是：ouyangqinbinNaN
console.log(stri1); //输出是：ouyangqinbinNaN
/* 任何数值和字符符串做加法运算，都会先把数值转换为字符串，然后再和字符串做拼接的操作 */
var numb5 = 100 + "200"; //结果是：100200
console.log(numb5); //输出是：100200
console.log(typeof numb5); //输出是：string 字符串类型
var numb6 = 100 + "false"; //结果是：100false
console.log(numb6); //
console.log(typeof numb6);
// - 运算符
var res = 100 -40;
console.log(res); //输出：60
var res1 = 100 - 140;
console.log(res1); //输出：-40
//字符串做减法也会转换为Number
var res2 = 100 + "15";
console.log(res2); //输出：10015
var res3 = 100 - "16";
console.log(res3);
//字符串中不只是数字而是由数字和字母组成
var res4 = 100 - "15ab";
var res5 = 100 - "ab45";
console.log(res4); //输出：NaN
console.log(res5); //输出：NaN
//1、非Number类型的值进行运算时，
var res6 = 100 -true;
console.log(res6); //输出：99
// * 运算符
var res7 = 100 * 123;
console.log(res7);
// / 运算符
var res8 = 100 / 25;
console.log(res8);
// 当分母为0时，
var res9 =100 / 0;
console.log(res9); //Infinity
// % 取余运算 number1 % number2
var res10 = 10 % 3;
console.log(res10);
var res11 = 10 % 2.5;
console.log(res11);
//m%n 求余，相当于m/n 获取余数 n等于0时 返回NaN.
var res12 = 100 % 0;
console.log(res12);
//m等于0时，结果为0；
var res13 = 0 % 120;
console.log(res13);
//m>n时 正常求余。9 % 4 =1
var res14 = 8 % 3;
console.log(res14);
//m<n时结果是m. 2 % 5 = 2;
var res15 = 3 % 8;
console.log(res15);
//正/负 运算符。
//正号不会对数字产生任何影响。
var numbe1 = 100;
console.log(numbe1);
var numbe2 = +100;
console.log(numbe2); //加上一个十号但是数值没有什么影响。
var numbe5 = -100;
var numbe6 =+ numbe5;
console.log(numbe6);
//对于非Number类型的值，会将转换为Number,然后再运算。
var numbe3 = +"15";
console.log(numbe3);
var numbe4 = + "45asdf";
console.log(numbe4);
//不会自动取数字部分。
//赋值运算符 =
//var 变量 = 数值;
var mun = 100;
var value = mun;
var value = mun =100;
mun = 90;
console.log(value);
console.log(mun);
//注意事项： 左边一定是变量，
/* 100 = 200;
200 = mun2;
都是错误写法。
*/
//复杂的 += -= *= /=
var a=100;
a+=10; //a=a+10;
console.log(a); //输出:110
var b=200;
b-=20; //b=b-20;
console.log(b); //输出：180
var c =100;
c *=100+30; //c=c(100+30);
console.log(c); //输出：13000
//从而得出：先算右边 再算复杂运算。
//自增、自减运算符
//在程序设计中，经常遇到 "i=i+1" 和 "i=i-1" 这两种极为常用的操作。
/*javascript语言为这种操作提供了两个更为简洁的运算符，即 ++ 和--,分别叫做自增运算符和自减运算符。*/
var i = 10, j = 20;
i+=1; //i++, ++i
j-=1; //i--, --i
console.log(i);
console.log(j);
var x = 10, y = 20, z = 30, z1 = 40;
x--;
--y;
z++;
++z1;
console.log(x);
console.log(y);
console.log(z);
console.log(z1);
//无论运算符号在前还是在后，变量在自身基础上都会改变。上面情况。
/*后缀表达式 x++ x--;先用x的当前值作为表达式的值，再进行自增自减运算。即“先用后变”，也就是先用变量的参与运算，变量的值再进行自增自减变化。*/
var x1 = 20, y1 = 30;
x1++;
y1++;
var z2 = x1 + y1;
console.log(z2); //输出：52
console.log(x1); //输出：21
console.log(y1); //输出：31
var x3 = 20, y3 = 30;
var z4 = (x3++) + (y3++); //结果：50
console.log("z4 ="+z4); //输出：50
console.log("x3 ="+x3); //输出：21
console.log("y3 ="+y3); //输出：31
//分开写的结果和综合写的结果是不一样的。
var x2 = 20, y2 = 30;
x2--;
y2--;
var z3 = x2 + y2;
console.log(z3); //输出：48
console.log(x2); //输出：19
console.log(y2); //输出：29
var x5 = 20, y5 = 30;
var z5 = (x5--)+(y5--); //结果：50
console.log("z5 =" + z5); //输出：50
console.log("x5 =" + x5); //输出：19
console.log("y5 =" + y5); //输出：29
/*前缀表达式 ++x --x;其中x表示变量名，先完成变量的自增或自减运算，再用X的值作为表达式的值，即“先变后用”，也就是变量的值先变，再用变量的值参与运算*/
var x6 = 20, y6 = 30;
--x6;
--y6;
var z6 = x6 + y6;
console.log("z6 =" + z6);
console.log("x6 =" + x6);
console.log("y6 =" + y6);
var x7 = 20, y7 = 30;
var z7 = (--x7) + (--y7);
console.log("z7 =" + z7);
console.log("x7 =" + x7);
console.log("y7 =" + y7);
var x8 = 30, y8 = 40;
++x8;
++y8;
var z8 = x8 + y8;
console.log("z8 =" + z8);
console.log("x8 =" + x8);
console.log("y8 =" + y8);
var x9 = 20, y9 = 30;
var z9 = (++x9) + (++y9);
console.log("z9 =" + z9);
console.log("x9 =" + x9);
console.log("y9 =" + y9);
//分开写的结果和综合写的结果是一样的。
</script>
</html>
10js运算符自增自减练习
<!DOCTYPE html>
<html>
<head>
<title>js运算符自增自减练习</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8"/>
</head>
<body>
</body>
<script>
var i = 2, j = 5;
//1、自增或自减在表达式中时，如果符号是在变量后面时。它会先用原值运算，后自增或自减
var z = i++ + j++;
document.write(z +"<br/>");
document.write("i =" +i +"<br/>");
document.write("i =" +j +"<br/>"+"<br/>");
var x = 5, y = 7;
var z =x-- + y--;
document.write(z +"<br/>");
document.write("x =" +x +"<br/>");
document.write("y =" +y +"<br/>"+"<br/>");
//2、自增或自减在表达式中时，如果符号是在变量前面时，它会先自增或自减后，再做运算。
var i1 = 8, j1 = 10;
var z1 = ++i1 + ++j1;
document.write(z1 +"<br/>");
document.write("i1 =" + i1 +"<br/>");
document.write("j1 =" + j1 +"<br/><br/>");
var x1 = 8, y1 = 10;
var z2 = --x1 + --y1;
document.write(z2 +"<br/>");
document.write("x1 =" + x1 +"<br/>");
document.write("y1 =" + y1 +"<br/><br/>");
//练习五
var n = 5, m = 6, z;
var z3 = ++n + ++m; //z = 13; 先做自增或自减。再参加运算。
document.write("z3 =" + z3 + "<br/><br/>");
// n = 6 m = 7
var z4 = ++n + m++; //z1 = 14; 第一个n是做自增或自减，再做去处，第二个m是先做运算再做自增或自减。
document.write("z4 =" + z4 + "<br/><br/>");
//n =7 m = 8
z5 = ++n + n++; //n=16; n++ 第一个n是做自增或自减，但是它会把值自动赋到第二个n上。最后再用n自增或自减。
document.write("z5 =" + z5 + "<br/>");
document.write("n =" + n +"<br/><br/>");
//这里第一个n是8，第二个n也是8；最后n是 9； //n的值有点乱。
var o =5, p=6,q;
q = ++o + p++; // q = 12 o = 6
document.write("q =" + q + "<br/>");
document.write("o =" + o + "<br/><br/>");
o = ++o + o++; // 第一个o为 7 它把o自动赋值到第二个o中。所以第二个o是7 // 14
document.write("o =" + o + "<br/><br/>");
var i2 = 0, j2, k2;
j2 = i2++; //j2 = 0 i2 = 1
k2 = --i2; //k2 = 0 i2 = 0 j2 = 0 k2 = 0 i2 = 0
document.write("i2 =" + i2 +"<br/>");
document.write("j2 =" + j2 +"<br/>");
document.write("k2 =" + k2 +"<br/><br/>");
//练习六
var i3 = 0, j3,k3;
j3 = ++i3 + i3++; //1+1 = 2 赋值给j3 i++ 2
console.log(j3);
document.write("j3 =" + j3 +"<br/>");
k3 = --i3 + i3--; //i3 = 1 k3 =2 i=0;
console.log(k3);
document.write("k3 =" + k3 +"<br/><br/>");
console.log(i3);
//练习七
var i4 = 5,j4,k4;
j4 = ++i4; //先自增或自减，再运算。 j4 = 6
k4 =--j4+i4; //先自增或自减，再运算。k4 = 11
console.log(j4);
console.log(k4);
document.write("j4 =" +j4 +"<br/>");
document.write("k4 =" +k4 +"<br/>");
k4 =i4+(++j4); //12
console.log(k4);
document.write("k4 ="+k4 +"<br/>" +"<br/>");
</script>
</html>
