JavaScript 基本概念之操作符、语句、函数

一元操作符

只能操作一个值的操作符叫做一元操作符。

递增和递减操作符

前置型

var age = 29;
++age;
alert(age);     		 	//30

var age2 = 29;
--age2;
alert(age2);				//28

var num1 = 2;
var num2 = 20;
var num3 = --num1 + num2;  	//21
var num4 = num1 + num2;		//21

后置型

var age = 29;
age++;
alert(age);					//30

var num1 = 2;
var num2 = 20;
var num3 = num1-- + num2;  	//22
var num4 = num1 + num2;		//21

一元加和减操作符

var num = 25;
num = +num;				//仍然是25

//一元操作符主要用于表示负数，例如将1转换成 -1
var num = 25;
num = -num;            //-25

布尔操作符
布尔操作符一共有3个：非(NOT)、与(AND)和或(OR)
逻辑非
逻辑非操作符由一个感叹号(!)表示,可用于ECMAScript中的任何值。无论这个值是什么数据类型,这个操作符都会返回一个布尔值。
逻辑非操作符首先会将它的操作数转换为一个布尔值，然后再对其求反。
逻辑非操作符转换规则和 Boolean()转换规则恰好相反

alert(!false);		//true
alert(!"blue");		//false
alert(!0);			//true
alert(!NaN);		//true
alert(!"");			//true
alert(!123456);		//false

//同时使用两个逻辑非操作符，实际上就会模拟 Boolean()转型函数。
alert(!!"blue");	//true
alert(!!0);			//false
alert(!!NaN);		//false
alert(!!"");		//false
alert(!!12345);		//true

逻辑与
逻辑与操作符由两个和号(&&)表示，有两个操作数

var result = true && false		//false

只有两个操作数都为true的时候才会返回true
逻辑与操作可以应用于任何类型的操作数，不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作数就不一定返回布尔值；此时应遵循以下规则：
1.如果第一个操作数是对象，则返回第二个操作数
2.如果第二个操作数是对象，则只有在第一个操作数的求值结果是true的情况下才会返回该对象
3.如果两个操作数都是对象，则返回第二个操作数
4.如果有一个操作数是null，则返回null
5.如果有一个操作数是NaN，则返回NaN
6.如果有一个操作数是undefined，则返回undefined

如果第一个操作数能够决定结果，那么就不会再对第二个操作数求值(例如第一个操作数是false,则结果一定是false)
逻辑或
逻辑或操作符由两个竖线符号(||)表示，有两个操作数

var result = true || false    //true

只有两个操作数都为false的时候才会返回false

与逻辑与类似，如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值，遵循以下规则：
1.如果第一个操作数是对象，则返回第一个操作数
2.如果第一个操作数求值结果为false，则返回第二个操作数
3.如果两个操作数都是对象，则返回第一个操作数
4.如果两个操作数都是null，则返回null
5.如果两个操作数都是NaN，则返回NaN
6.如果两个操作数是undefined，则返回undefined

可以利用逻辑或的行为来避免为变量赋null或undefined值

var myObject = obj1 || obj2;

变量myObject 将被赋予等号后面两个值中的一个。如果obj1的值不是null或undefined，那么它的值赋给myObject;如果是null,则将obj2赋给myObject
乘性操作符
ECMAScript定义了3个乘性操作符：乘法、除法和求模。

乘法

var result = 34 * 56;

 除法

var result = 66 / 11;

求模(余数)

var reslut = 26 % 5;   		//1

加性操作符
加法

var result = 1 + 2;			//3
var result2 = 5 + "5";		//55

减法
如果有一个操作数是对象、布尔值、null或undefined,则先在后台自动调用Number()函数将其转换为数值，然后在计算

var result = 2 - 1;			//1
var result1 = 5 - true;		//4,因为true被转换成了1
var result2 = NaN - 1;		//NaN
var result3 = 5 - "";		//5,因为"" 被转换成了0
var result4 = 5 - "2";		//3,因为"2" 被转换成了2
var result5 = 5 - null;		//5,因为null 被转换成了0

关系操作符
小于(<)、大于(>)、小于等于(<=)和大于等于(>=),返回一个布尔值

var result1 = 5 > 3;   			//true
var result2 = 5 < 3;			//false

相等操作符
相等和不相等
相等(==)、不相等(!=) : 两个操作符都会先转换操作数(通常称为强制转换)，然后再比较它们的相等性
比较相等性之前，不能将null和undefined转换成其他任何值

var result1 = ("55" == 55);	//true,因为转换后相等
var result2 = ("55" === 55);//false,因为不同的数据类型不相等

var result3 = ("55" != 55);	//false,因为转换后相等
var result4 = ("55" !== 55);//true,因为不同的数据类型不相等

全等和不全等

全等(===)、不全等(!==) : 在两个操作数未经转换就相等或不相等的情况下返回true

var result1 = ("55" == 55);	//true,因为转换后相等
var result2 = ("55" === 55);//false,因为不同的数据类型不相等

var result3 = ("55" != 55);	//false,因为转换后相等
var result4 = ("55" !== 55);//true,因为不同的数据类型不相等

条件操作符

var max = (num1 > num2) ? num1 : num2;

赋值操作符

由等与号(=)表示

var num = 10;

逗号操作符

var num1 = 1, num2 = 2, num3 = 3;    //同时声明多个变量
var num2 = {5, 1, 2, 4, 6};   		 //6(赋值:总会返回表达式的最后一项)

do-while 语句

var i = 0;
do{
	i += 2;
}while(i < 10)

alert(i);		//10

while 语句

var i = 0;
while(i < 10){
	i += 2;
}

for 语句

var count = 10;
for (var i = 0; i < count; i++){
	alert(i);
}

for(;;){	//无限循环
	doThing();
}

for-in 语句

for (var proName in window){
	document.write(proName);
}

label语句

使用label语句可以在代码中添加标签，以便将来使用。
语法: label:statement

start: for (var i=0; i < count; i++){
	alert(i);
}

这里定义的start标签可以在将来有break或continue语句引用。加标签的语句一般都要与for语句等循环语句配合使用

break 和 continue

var num = 0

for (var i=1; i < 10; i++){
	if (i % 5 == 0){
		break;
	}
	num++;
}

alert(num);    //4

var num2 = 0

for (var i=1; i < 10; i++){
	if (i % 5 == 0){
		continue;
	}
	num2++;
}

alert(num2);    //8

//与label配合使用
var num3 = 0

outermost:
for (var i=0; i < 10; i++){
	for (var j=0; j < 10; j++){
		if (i ==5 && j==5){
			break outermost;
		}
		num3++;
	}
}

alert(num3);    //55(break语句不仅会退出内部的for语句,而且也会退出外部的for语句)

with 语句

with 语句的作用是将代码的作用域设置到一个特定的对象中。主要是简化多次编写同一个对象的工作

var qs = location.search.substring(1);
var hostName = location.hostname;
var url = location.href;
简化如下:
with(location){
	var qs = search.substring(1);
	var hostName = hostname;
	var url = href;
}

使用with语句关联了location对象。这意味着在with语句的代码块内部，每个对象首先被认为是一个局部变量，而如果在局部环境中找不到该
变量的定义，就会查询location对象中是否有同名的属性。如果发现有同名属性，则以location对象属性的值作为变量的值。

switch 语句

switch(i){
	case 25:
		alert("25");
		break;
	ase 35:
		alert("35");
		break;
	default:
		alert("Other");
}
//可以在switch语句中使用任何数据类型，无论是字符串，还是对象都没有问题。其次，每个case的值不一定是常量，可以是变量，甚至是表达式。
switch("hellow world"){
	case "hellow"+" world":
		alert("Hello World!");
		break;
	case "goodbye":
		alert("byebye");
		break;
	default:
		alert("Other");
}
//使用表达式
var num = 25;
switch(true){
	case num < 0:
		alert("Less than 0");
		break;
	case num >=0 && num <= 10
		alert("Between 0 and 10");
		break;
	case num > 10 && num <= 20
		alert("Between 10 and 20");
		break;
	default:
		alert("More than 20");
}

switch 语句在比较值时使用的是全等操作符，因此不会发生类型转换(例如，字符串"10"不等于数值10)

函数

function sayHi(name, message){
	alert("Hello "+ name + "," + message);
}
//函数的参数并不是必要的，可通过 arguments 对象来访问参数数组，从而获取给函数的每一个参数
function sayHi(){
	alert("Hello " + arguments[0] + "," + arguments[1]);
}

//使用 length 属性来确定传递进来多少个参数
function howManyArgs(){
	alert(arguments.length);
}

howManyArgs("string", 45);	//2
howManyArgs();				//0
howManyArgs(12);			//1