JavaScript基础

<script>
//JavaScript脚本可以使用标签，方便快速的定位
loop:for(var j = 1; j < 6; j++){
		if (j == 2)
			continue loop;
		document.write("<br>" + j);
	}
</script>
<script>
//标签在双层循环中有效果
//看着像goto语句
loop:for(var j = 1; j < 6; j++){
		document.write("<br>" + j + ":");
		for (var i = 1; i < 6; i++){
			if (i == 3) continue loop;
			document.write(i);	
		}
	}
</script>

//公共函数
function strlen(s){
	var len;
	len = 0;
	for (i = 0; i < str.length; i++){
		if (str.charCodeAt(i) > 255)
			len += 2;	//双字节字符，增加2
		else 
			len++;		//单子数，增加1
	}
	
	return len;
}

// JavaScript Document
/*
	一些基本的语法：
		var 指令表示定义变量，function指令表示定义函数，return指令表示返回值
			对象{}:对象内容包含在一对大括号中，里面的内容是 名/值 对，多个 名/值 对之间是没有先后顺序的。
		每个明知对内的名称和值之间使用冒号进行分隔，每个 名/值 对之间使用逗号分开，其中的名称为字符串，值
		则可以是数值、字符串、函数。获取对象中的属性值，使用，对象名 + 点 + 属性名的方式。
			类比于Java，和Java中的集合中的Map<String, Object>相似
*/

var me = {
		name:"张三",
		say:function(){
			return "Hi, World";	
		}
	}

document.write("<h1>" + me.name + ":" + me.say() + "</h1>");

/*
	js中的数组（array）：
			数组是值（value）的有序的集合，数组内容放在一对中括号[]内。组很灵活相当于对象的有序集合。
		其中的值可以是方法，获取数组中的值的方法，数组名[下表]，如果值的内容是方法的话 数组名[下表]()
		类似Java中的List<Object>
*/
var me = [
			"张三", 
			function(){
				return "Hi, World";	
			}
		]
document.write("<h1>" + me[0] + ":" + me[1]() + "</h1>");

<script>
//switch语句是按照case后面的表达式找到和switch相同（===）的内容
var age = prompt('您好，请输入你的年级', "");
//prompt两个参数，第一个是提示信息，第二个是默认信息
//alert用来做提示
switch (age) {
	case "1":
		alert("你上一年级");
		break;
	case "2":
		alert("你上二年级");
		break;
	case "3":
		alert("你上三年级");
		break;
	default:
		alert("不知道你上几年级");
}
</script>

<script>
//跳转语句可以和标记相结合，跳转到指定的行，而不是跳转出循环
x:for(a = 1; a < 10; a++){
	document.write("</br>" + a + "</br>");
	for(var b = 1; b < 10; b++){
		if (a > 5)
			break x;
		document.write(b);
	}	
}
//continue语句的用法额break相似，唯一的区别是continue语句不会退出循环，而是开始新的迭代。
//continue语句只能用于循环语句的循环体中。
</script>

<script>
//异常处理
try {
	alert("执行程序");
	var err = new Error("异常");
	throw err;	
}
catch (e) {
	alert("错误名称：" + e.name + "\n错误信息:" + e.message);
}
finally{
	alert("finally");	
}
</script>

<script>
/*
	JavaScript是一种弱类型语言，一个变量可以存储任何类型的值。
	但是着并不等于JavaScript不区分数据类型
	js数值不区分整型和浮点型，所有的数值都为浮点型数值来表示
	使用toString可以将数值转换成字符串
	使用parseInt和parseFloat将字符串转换成整型和浮点型，也可以通过将字符串乘以1来实现
	js中的几种特殊的数值：
		Infinity 无穷大    NaN  非数值
		Number.MAX_VALUE  可以表示的最大值
		Number.MIN_VALUE  可以表示的最小值
		Number.NaN	非数值
*/
var a = 100;
var c = a.toString();
alert(typeof(c));

var a = 100;
var c = a + "";
alert(typeof(c));

var str = "123";
var str = "JavaScript'不是'Java";
alert(str);

var str = "123.0";
var a = parseInt(str);
var b = parseFloat(str);
var c = str * 1;
document.write(a + ": " + typeof(a) + "</br>" + b + ": " + typeof(b) + "</br>" + c + ": " + typeof(c));
</script>

<script>
/*
	任何非0的数转换成布尔值为true，而0转换成布尔值为false
    任何非空的字符串转换成布尔值为true，而空字符串转换成布尔值为false
    把布尔值转换成字符串，true为"true"，false为"false"
    把布尔值转换成数值，true为1，false为0
*/
var a = 100;
var c = !!a;
alert(typeof(c) + " : " + c);

var a = true;
var b = false;
a = a + "";
b = b + "";
alert(a + ", " + b);

var a = true;
var b = false;
a = a * 1;
b = b * 1;
alert(a + ", " + b);
</script>

/*
		null是Null类型的值，Null类型的值只有一个值（null），表示空值。当对象为空，或者变量没有引用
	任何对象，其返回值为null。当一个变量的值为null，则表明它的值不是有效的对象，数组，数值，字符串和布尔值等。
	如果使用typeof进行检测null值的类型，返回的是object，说明它是一个特殊的对象。
		undefined表示未定义的值，当变量为初始化的时候，会默认其值为undefined，使用typeof进行检测，其返回值为undefined
*/

<script>
var say = function(name, say){
		document.write("<h1>" + name + ": " + say + "</h1>");
	}
say("张三", "Hi！");

function f(){
		return "Hello, World!";
	}

document.write(f());

function add(a, b){
	return a + b;
}
//add.length返回的是参数的个数
alert(add.length);
//js中并没有规定函数的参数个数必须和调用该函数的时候传递的参数个数相同
//如果实参大于形参的个数，那么多余的将被舍弃；如果实参小于形参的个数，那么多出来的形参值为undefined
alert(add(2,3,4));	//返回值为5
alert(add(2));		//返回值为NaN表示不是数值
</script>

/*
	arguments对象，利用该对象可以快速的操纵函数的实参。
	argements.length可以获得函数实参的个数，使用数组下标可以获得实际传递给函数的每个参数值
*/

function add(a, b){
		if (add.length != arguments.length){
			throw new Error("实参很形参不一致，请重新调用函数！");
		}
		else
			return a = b;
	}

try {
	alert(add(2));	
}
catch (e){
	alert(e.message);	
}
</script>

<script>
//函数的应用
var z = function(x, y){
		return (x + y) / 2;
	}(23,35);
document.write(z);

(function(x, y){
		 alert(x + y) / 2;
	}) (4, 6);

/*
	闭包函数
	闭包是一个拥有许多变量和绑定了这些变量的环境的表达式（通常是一个函数）
	闭包函数就是外部函数被调用后，它的变量不会消失，仍然被内部函数所使用，而且所有的内部函数都拥有对外部函数的访问权限。
*/

function a (){
		var n = 0;
		function b(m){
			n = n + m;
			return n;
		}
		return b;
	}
	
var c = a();
document.write("</br>" + c(3));
document.write("</br>" + c(3));
document.write("</br>" + c(3));
/*
	输出的值分别为3 6 9 
	如果没有闭包函数的作用，当调用外部函数a()之后，其定义的私有变量就不再存在，也就无法实现值的递增效果
*/
</script>

<script>
	/*
		创建对象和访问对象
		对象的值可以是简单的值，也可以是复杂的值，如函数，对象
	*/
	var point = {
			x:2.3,
			y:-1.2
		};
	var x = point.x;
	document.write("</br>" + x);
	
	var point2 = {
			f : function(){
				return this.y;
			},
			y : -1.2
		};
	var y = point2.f();
	document.write("</br>" + y);
	
	var point = {
		x : {
			a :1,
			b : 2	
		},
		y : -1.2
	}
	var a = point.x.a;
	document.write("</br>" + a);
	var b = point["x"]["b"];
	document.write("</br>" + b);
</script>

//js中的常量和变量
/*
常量内容：
	Math.E		自然对数的底数
	Math.LN10	10的自然对数
	Math.LN2	2的自然对数
	Math.LOG10E	以10为底的e的对数
	Math.LOG2E	以2为底的e的对数
	Math.PI
	Math.SORT1_2	2的平方根除以1
	Math.SORT2		2的平方根
	Math.MAX_VALUE	可表示最大值
	Math.MIN_VALUE	可表示最小值
	Number.NEGATIVE_INFINITY	正无穷大
	Number.POSITIVE_INFINITY	负无穷大
*/
//使用var声明变量，变量名由字母、数字、下划线、美元符组成，不以数字开头。
/*
	在函数内部使用var关键字声明的变量就是私有变量，该变量的作用域仅限于当前函数体内，但是
如果不适用var关键字都是全局变量，不管是在函数内部或函数外，在整个页面脚本中都是可见的。
运算符：
	>> 算术右移，将第一操作数的二进制形式的第一位向右移位，所移动的数目由第二操作数指定。
忽略被移除的位。
	>>>逻辑右移，忽略被移除的位，左边的空位补0
	===如果操作数完全相同，则返回真
	!==如果操作数不完全相同，则返回真 
	 
*/

<script>
/*
	数组中的每一个参数都表示数组的一个元素值，数组的元素没有类型的限制。通过数组的length属性可以确定数组的长度
	方法：delete(), push(). pop(), unshift(), shift(), splice(), join()
*/
	var a = new Array();
	var b = new Array(6);
	document.write(a.length + ", " + b.length + "</br>");
	var a = [1, 2, 3, "4", "5"];
	document.write(a);//顺序输出数组中的每一个元素
	
	//遍历数组
	var str = "";
	var a = [1, 2, 3, 4, 5];
	for (var i = 0; i < a.length - 1; i++){
		str += a[i] + "-";
	}
	
	str += a[a.length - 1];
	
	document.write("</br>" + a);
	document.write("</br>" + str);
	
	//修改数组的长度，直接修改length属性，将多余的删除
	var a = [1, 2, 3, 4, 5];
	a.length = 4;
	document.write("</br>" + a.length + " ： " + a);
	//使用push()和pop()从数组尾部修改数组内容
	var a = [];
	a.push(1, 2, 3);
	a.push(4, 5);
	document.write("</br>" + a);
	a.pop();
	document.write("</br>" + a);
	//使用unshift()和shift()从数组首部修改数组内容
	var a = [];
	a.unshift(1, 2, 3);
	a.unshift(4, 5);
	document.write("</br>" + a);
	a.shift();
	document.write("</br>" + a);
	//通用的删除和插入元素的方法splice()
	//splice有三个参数，第一个是操作的起始下标位置，第一个参数表示截取的字符长度，第三个及其以后的内容表示添加的内容
	var a = [1, 2, 3, 4, 5];
	var b = a.splice(2, 2);//将数组a从下表为2长度为2的内容截取给变量b
	document.write("</br>" + b);//输出的内容是3，4
	var a = [1, 2, 3, 4, 5];
	var b = a.splice(2, 2, 7, 8, 9);//截取数组a从下标为2开始长度为2的子数组内容传递给b，将7,8,9添加到下标为2的位置
	document.write("</br>" + b);
	document.write("</br>" + a);
	
	//使用Array对象的join()方法可以将数组转换成多种形式的字符串
	//join()方法包含一个参数，表示用来合并数组元素的连字符，如果没有指定默认值为逗号
	var a = [1, 2, 3, 4, 5];
	a = a.join("-");
	document.write("</br>a的类型 = " + typeof(a));
	document.write("</br>a的值 = " + a);
	
	//使用split()函数将字符串转换成数组，包含两个参数，第一个指定分隔符，第二个指定长度
	var a = [1, 2, 3, 4, 5];
	a = a.join("-");
	var s = a.split("-");
	document.write("</br>s的类型" + typeof(s));
	document.write("</br>s的值 = " + s);
	
	//函数reverse()可以将函数逆序输出
	var a = [1, 2, 3, 4, 5];
	a = a.reverse();
	document.write("</br>" + a);
	
	//数组排序
	//sort()排序的方法是通过其参数来决定的。这个参数是一个比较两个元素值的闭包。如果省略参数，则sort()方法将按照默认的规则对数组进行排序
	var a = [2, 3, 5, 1, 4];
	var f = function(x, y){
		return y - x;	
	};
	var b = a.sort(f);
	document.write("</br>" + b);
	var b = a.sort();
	document.write("</br>" + b);
	
	//连接数组
	//使用concat()函数连接数组，如果参数内容中包含数组，会将参数中的数组展开添加到数组中
	var a = [1, 2, 3, 4, 5];
	var b = a.concat([4, 5], [1, [2, 3, 4, 5]]);
	document.write("</br>" + b);
	document.write("</br>");
	for (var i = 0; i < b.length; i++){
		document.write(b[i] + "; ");	
	}
	b = b.join("-");
	document.write("</br>" + b);
	/*
		1; 2; 3; 4; 5; 4; 5; 1; 2,3,4,5;
		1-2-3-4-5-4-5-1-2,3,4,5 
		通过输出结果可以看出，concat()函数只能将里面的第一层数组展开
	*/
	
	//使用slice()截取子数组第一个参数是起始下标，第二个参数是长度
	var a = [1, 2, 3,4, 5];
	var b = a.slice(2, 5);
	document.write("</br>" + b);
	
</script>