JS高程NO3--基本概念（语法，数据类型，操作符，语句，函数）

语法
ECMAScript中的一切都区分大小写；
标识符：变量，函数，属性的名字，或者函数的参数；
              第一个字符必须是字母，下划线（_），美元（$），其他字符可以是字母，下划线，美元复活或数字；
              驼峰大小写命名。
注释： // 单行；/* */ 多行
严格模式：“use strict”; ——它是一个编译指示，用于告诉支持JavaScript引擎切换到严格模式。
                    function fn(){
                        "use strict";
                        //函数体
                    }

关键字和保留字

关键字：（*是第5版新增）

break	do	instanceof	typeof
case	else	new	var
catch	finally	return	void
continue	for	switch	while
debugger*	function	this	with
default	if	throw
delete	in	try

保留字：

abstract	enum	int	short
boolean	export	interface	static
byte	extends	long	super
char	final	native	synchronized
class	float	package	throws
const	goto	private	transient
debugger	implements	protected	volatile
double	import	public	let
yield	eval	arguments

*使用关键字作标识符，会导致"Identifier Expected" 错误。而保留字可能会也可能不会导致相同的错误，具体取决于特定的引擎。
*在严格模式下，eval 和arguments 也不能作为标识符或属性名，否则会抛出错误。

变量

变量是松散类型，可以用来保存任何类型数据。
var a ; ——像这样未经过初始化的变量会保存一个特殊值：undefined。
用var操作符定义的变量将成为该变量的作用域中的局部变量。（用var定义的变量在函数退出后就会被销毁）

数据类型

五种基本数据类型：number，boolean，string，null，undefined（特殊值）；

一种复杂数据类型：Object （是由一组无序的名值对组成）；

typeof操作符——用来检测变量的数据类型



*typeof null会返回“object”，因为特殊值null是一个空的对象引用

Undefined类型

var a; //用var声明但未初始化变量默认值：undefined//var b; //未声明变量
alert(a); //undefinedalert(b); //报错：Uncaught ReferenceError: b is not defined
alert(typeof a); //undefinedalert(typeof b); //undefined//因为这两种变量从技术角度看有本质区别，实际上无论对哪种变量都不可能执行真正的操作。
即便未初始化的变量会自动被赋予undefined的值，如果能显示初始化变量（var
a=undefined;），那么当typeof操作符返回undefined，就知道被检测的变量还没有被声明，而不是尚未初始化。

Null类型

因为null是空对象指针，typeof
null会返回“object”。
undefined值是派生自null值，所以alert(null==undefined);  //true

无论在什么情况下都没有必要把一个变量对的值显示地设置为undefined，但是对null不适用。
只要意在保存对象的变量还没有真正保存对象，就让该变量保存为null值，能体现null作为空对象指针的惯例，而且进一步区分null和undefined；

Boolean类型——true和false

要将一个值转换为其对应的Boolean值，可以调用转型函数Boolean()。

var a="hi";

var result=Boolean(a);

可以对任何数据类型的值调用Boolean()函数，而且总会返回一个Boolean值。

数据类型	转换为true的值	转换为false的值
Boolen	true	false
String	任何非空字符串	""(空字符串)
Number	任何非零数字值（包括无穷大）	0和NaN
Object	任何对象	null
Undefined	n/a(不适用)	undefined

Number类型

最基本的数值字面量格式是十进制整数。

八进制：第一位必须是零（0），然后八进制数字序列（0~7），超出范围，前导零被忽略，按十进制数值解析

十六进制：前两位必须是 0x，后面跟任何十六进制数字（0~9和A~F）

浮点数值

         
数值中必须包含一个小数点，并且小数点后面必须至少有一位数字。

          保存浮点数值需要的内存空间是保存整数值的两倍。

          e表示法：var floatNum = 3.125e7; ------31250000(3.123乘以10的7次方)
数值范围
         超出JavaScript数值范围的值，会自动转换成 Infinity（正无穷），-Infinity（负无穷）
NaN（Not a Number）
          特点一：任何涉及NaN的操作都会返回NaN；

          特点二：NaN与任何值都不相等，包括NaN本身； 

                        alert(NaN==NaN); //false

          针对NaN的两个特点，定义了isNaN( )函数。在接收到一个值之后，会转换为数值，而任何不能转换为数值的值都会返回true

                        alert(isNaN(NaN)); //true;

                        alert(isNaN(10));
//false;

 
                      alert(isNaN("10")); //false;

 
                      alert(isNaN("blue")); //false;

 
                      alert(isNaN(true)); //false;

数值转换
Number( );
Boolean——true和false将被转换为1和0
Number——只是简单传入返回
Null——0
Undefined——NaN
String——遵循以下规则：
字符串中只包含数字，转换为十进制数值，十六进制格式也转换为相同大小的十进制整数值
字符串有浮点格式，转换相对应的浮点数值
字符串为空（不包含任何字符），转换为0     Number("")——0
除了上述格式外，转换为NaN

对象——调用对象的valueOf( )方法，然后依照前面的规则转换返回的值。如果转换的结果是NaN，则调用toString( )。

parseInt( );
在转换字符串是，更多的是看其是否符合数值模式；
用parseInt( )转换空字符串会返回NaN；  parseInt("")——NaN
parseInt( )解析八进制字符串，ECMAScript 3和ECMAScript 5存在分歧
parseInt("10",10); ——第二个参数是要解析一个十进制格式的字符串

parseFloat( );
第一个小数点有效，第二个小数点无效
与parseInt( )区别：它始终都会忽略前导的零
parseFloat( )只解析十进制，十六进制的字符串会返回为0
parseFloat(3.125e7)——31250000

String类型

用于表示由零或多个16位Unicode字符组成的字符序列——字符串

八进制：第一位必须是零（0），然后八进制数字序列（0~7），超出范围，前导零被忽略，按十进制数值解析

十六进制：前两位必须是 0x，后面跟任何十六进制数字（0~9和A~F）

转义序列：\n 换行，\r 回车，\\ 斜杠，\' 单引号，\" 双引号，\unnnn Unicode字符

转换为字符串

toString( )
          每个值（数值，布尔值，对象，字符串值)都有toString( )，除了null和undefined；
          var age=11 ; var ageAsString= age.toString( );  // "11"
          默认toString( )不用传递参数。但是调用数值的toString( )方法，可传递一个参数：输出数值的基数，默认是十进制
          var num=10; alert(num.toString(10));  // "10"

String( )
          在不知道转换的值是null还是undefined，就用转型函数String( )

Object类型——是这门语言中所有对象的基础类型。

一组数据和功能的集合；Object类型是所有它的实例的基础（Object类型所具有的任何属性和方法同样存在于更具体的对象中）；

Object的每个实例都具有下列属性和方法：

constructor（构造函数）：保存着用于创建当前对象的函数
hasOwnProperty（propertyName）：用于检查给定的属性在当前对象实例中（不是实例的原型中）
isPrototypeOf（object）：用于检查传入的对象是否是传入对象的原型
prototypeIsEnumerable（prototypeName）：用于检查给定的属性是否能够使用for-in语句来枚举
toLocaleString( )：返回一个 String 对象，这个对象中包含了用当前区域设置的默认格式表示的日期
toString( )
valueOf( )

操作符

递增递减操作符（++，--）

前置型 ++a（先运算后赋值）

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

后置型 a++（先赋值后运算）

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

在不同值，递增递减操作符应用

var s1="2";var s2="z";var b=false;var f=1.1;var o={valueOf:function(){return -1;}};s1++;s2++;b++;--f;--o;console.log(s1); //3console.log(s2); //NaNconsole.log(b); //1console.log(f); //0.10000000000000009console.log(o); //-2

一元加减操作符（+，-）

对数值应用一元操作符：var num=5; num=+num;
对非数值应用一元操作符：会像Number( )转型函数一样对这个值进行转换。
一元加减操作符主要用于基本的算术运算，也可以用于转换数据类型

位操作符 P39

按位非（~）：操作数的负值减1；

var num1=25;var num2=~num1; // num2=-num1-1; 因为按位非是在数值表示的最底层执行操作，速度更快alert(num2) // -26

按位与（&）：只在两个数值的对应位都是1时才返回1，任何一位是0，结果都是0； 

var result=25 & 3;alert(result) // 1



按位或（|）：在有一个位是1的情况下返回1，而只有在两个位都是0的情况下才返回0； 

var result=25 | 3;alert(result) // 27



按位异或（^）：与按位或不同之处是在两个数值对应位上只有一个1时才返回1，如果对应的两位都是1或者0，则返回0； 

var result=25 ^ 3;alert(result) // 26



左移（<<）：将数值的所有位向左移动指定的位数，左移不会影响操作数的符号位；var a=4; var b=a<<5;
有符号的右移（>>）：会将数值向右移动，但保留符号位
无符号的右移（>>>）：将数值的所有32位都向右移动。对正数来说，无符号右移和有符号右移一样的。对负数来说，无符号右移是以0来填充，不像有符号右移以符号位的值来填充。所以会把负数的二进制码当成正数的二进制码。而且，由于负数以绝对值的二进制补码形式表示，会导致无符号右移后的结果非常大。

布尔操作符

逻辑非（！）：首先会将他的操作数转换为一个布尔值，然后再对其求反；使用两个逻辑非（！！）模拟Boolean( )转型函数的行为
对象——false
空字符串——true
非空字符串——false
0——true
非0（包括Infinity）——false
null——true；
undefined——true
NaN——true

逻辑与（&&）：&&属于短路操作，就是第一个操作数结果是false，不在对下一个操作数求值。
第一个操作数是对象——返回第二个操作数
第二个操作数是对象——只有在第一个操作数的求值是true才返回第二个参数对象
两个操作数都是对象——返回第二个操作数
有一个是null——null；
有一个是NaN——NaN；
有一个是undefined——undefined

逻辑或（||）：||也属于短路操作，就是第一个操作数结果是true，不在对下一个操作数求值。
第一个操作数是对象——返回第一个操作数
第一个操作数结果false——返回第二个操作数
两个操作数都是对象——返回第一个操作数
两个是null——null；
两个是NaN——NaN；
两个是undefined——undefined

                可以利用逻辑或来避免为变量赋null或undefined值
                var myObject=preferredObject || backupObject ;
                变量preferredObject中包含优先赋给myObject的值，变量backupObject负责在preferredObject中不包含有效值的情况下提供后备值。preferredObject不是null，直接赋值给myObject；如果是null，就用backupObject的值赋给myObject。

乘性操作符：乘法，除法和求模

乘法（*）：

两个都是数值，按照乘法来运算。超出范围返回Infinity或-Infinity；
一个是NaN——NaN；
Infinity * 0 ——NaN；
Infinity * 非0 ——Infinity/-Infinity（取决于有符号操作数的符号）；
Infinity * Infinity ——Infinity；
有一个不是数值，在后台调用Number( )转换为数值，然后应用上面的规则

除法（/）：

两个都是数值，按照除法来运算。超出范围返回Infinity或-Infinity；
一个是NaN——NaN；
Infinity / Infinity ——NaN；
0 / 0 ——NaN；
非0的有限数 / 0 ——Infinity/-Infinity（取决于有符号操作数的符号）；
Infinity / 非0 ——Infinity/-Infinity（取决于有符号操作数的符号）；
有一个不是数值，在后台调用Number( )转换为数值，然后应用上面的规则

求模（%）：余数

两个都是数值，按照除法来运算，返回除得的余数；
无穷大值 % 有限大的数值 ——NaN；
有限大的数值 % 0 ——NaN；
Infinity % Infinity ——NaN；
被除数是有限大的数值 % 无穷大值 ——被除数；
被除数是0——0；
有一个不是数值，在后台调用Number( )转换为数值，然后应用上面的规则

加性操作符：加法，减法

加法（+）：

两个都是数值，按照加法来运算；
一个是NaN——NaN；
Infinity + Infinity ——Infinity；
-Infinity + -Infinity —— -Infinity；
Infinity + -Infinity ——NaN；
+0 + +0 —— +0；
-0 + -0 —— -0；
+0 + -0 —— +0；

有一个是字符串：
两个都是字符串，两个数拼接起来；
如果只有一个是字符串，那就将另一个转换为字符串，然后将两个拼接起来；

有一个是对象，布尔值或数值，则调用它们的toString( )方法取得相应的字符串值，然后应用前面关于字符串的规则；
undefined 和 null 分别调用toString( )并取得字符串"undefined"和"null"

var num1=5;var num2=10;var a="the num is "+num1+num2; //the num is 510;var b="the num is "+(num1+num2); //the num is 15;alert(a);alert(b);
减法（-）：

两个都是数值，按照减法来运算；
一个是NaN——NaN；
Infinity - Infinity ——NaN；
-Infinity - -Infinity ——NaN；
Infinity - -Infinity ——Infinity；
-Infinity - -Infinity ——  -Infinity；
+0 - +0 —— +0；
-0 - -0 —— +0；
+0 - -0 —— -0；

有一个是字符串，布尔值，null或undefined：先在后台调用Number( )转换为数值，然后应用前面的减法规则；如果转换的结果是NaN，返回结果是NaN；
有一个是对象，则调用对象valueOf( )方法取得表示该对象的数值。如果得到的值是NaN，结果是NaN；如果对象没有valueOf( )方法，则调用toString( )方法并将得到的字符串转换为数值；

关系操作符：小于，大于，小于等于，大于等于

两个都是数值，比较数值大小；
两个都是字符串，比较字符串对应的字符编码值；
大写字母的字符编码全部小于小写字母的字符编码，如果要真正按字母表顺序比较字符串，先把两个都转换为相同的大小写形式，然后再比较。var result="Name".toLowerCase( ) < "age".toLowerCase( );
当两个数字的字符串，不是比较数字大小，是字符编码大小。var result="23"<"3"; //true;  -->var result="23" <3; //false （将一个操作数改为数值，比较结果就正常了）

一个是数值，另一个就转换为一个数值，然后比较数值大小；
一个是对象，则调用这个对象的valueOf( )，用得到的结果按照前面的规则比较。如果没有valueOf( )，就用toString( )；
一个是布尔值，先转换数值，然后数值比较大小；
任何与NaN比较，都是false

相等操作符：相等和不想等，全等和不全等

相等和不想等（==和！=）——先转换在比较
一个是布尔值，先转换数值；
一个是字符串，另一个是数值，先把字符串转换为数值；
如果一个是对象，另一个不是，调用valueOf( )，得到的基本类型值按照前面规则比较
null==undefined；
在比较相等性之前，null和undefined不能转换成其他任何值；
一个是NaN，相等操作符返回false；不相等操作符返回true；
NaN == NaN; //false
两个都是对象，比较是不是同一个对象，如果都指向同一个对象，就相等；



全等和不全等（===和！==）——以不转换数值的方式进行比较
      null===undefined;  ——false，因为它们不是同一类型的值

条件操作符：variable = boolean_expression ? true_value : false_value ;

赋值操作符：（=）——作用就是把右侧的值赋给左侧的变量

在=前面添加乘性操作符，加性操作符或位操作符，可以完成复合复制操作。
          num +=10 ; ——num = num + 10；
          目的：简化赋值操作，不会带来任何性能的提升。

逗号操作符：（，）

多用于声明多个变量
还可以用于赋值，逗号操作符总会返回表达式中的最后一项。var a=(5,1,2,9,3); //a的值是3

语句（流控制语句）

if 语句
if (condition)
statement1 else statement2

其中 condition 可以是任何表达式，结果不一定是布尔值。ECMAScript 会自动调用Boolean( )转换函数把它转换成布尔值。
如果条件结果为 true，则执行 statement1；如果条件结果为
false，则执行 statement2。
每个语句都可以是单行代码，也可以是代码块。

do-while 语句——后测试循环语句（只有在循环体中的代码执行之后才会测试出口条件）

do {
    statement
} while（expression）

像do-while这种后测试循环语句最常用于循环体中的代码至少要被执行一次的情形。

while 语句——前测试循环语句（在循环体内的代码被执行之前，就会对出口条件求值）


while （expression）statement 

前测试循环语句的循环体内的代码有可能永远不会被执行。

for 语句——前测试循环语句，但具有在执行循环之前初始化变量和定义循环后要执行的代码能力。

for （initialization；
expression； post-loop-expression）statement 

            初始化表达式        控制表达式                 循环后表达式
这三个表达式都是可选的，如果都全部省略，就会创建一个无限循环。
for（; ;） doSomething（）；

而只给出控制表达式实际上就把for循环转换成了while循环。

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

for-in 语句——精准的迭代语句，可以用来枚举对象的属性。

for （property in expression）statement 

ECMAScript对象的属性没有顺序，因此，通过for-in循环输出的属性名的顺序会因浏览器而异。

如果要迭代的对象的变量值为null或者undefined，for-in会抛出错误。ECMAScript5已更正：不再抛出错误，而只是不执行循环体。为了保证最大限度兼容性，建议在使用for-in前，先检测对象的值不是null或undefined。

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

label ：statement
示例：

start:for(var i=0; i<count; i++){ alert(i);}
这例子中定义的start标签可以在将来由break或continue语句引用。加标签的语句一般都要与for语句等循环语句配合使用。

break 和 continue 语句——用在循环中精确地控制代码的执行。

break； 会立即退出循环，强制继续执行循环后面的语句。
continue； 也会立即退出循环，但退出循环后会从循环的顶部继续执行。

break 和 continue 语句都可以与label语句联合使用，从而返回代码中特定的位置。一般多发生在循环嵌套的情况下。（使用过度，会给调试带来麻烦，所以使用label一定要使用描述性的标签，同时不要嵌套过多的循环。）

var num=0;outermost:for(var i=0; i<10; i++){ for(var j=0; j<10; j++){ if(i==5 && j==5){ break outermost; } num++; }}alert(num); //55
循环正常执行10次的话，num值是100；
但内部循环中的break语句带了一个参数：要返回到的标签。
添加这个标签的结果将导致break语句不仅会退出内部的for语句，也会退出外部的for语句。

把break改为continue，num值是95。

continue会强制继续执行循环——退出内部循环，执行外部循环。当j是5时，内部循环你少执行5次。

with 语句——将代码的作用域设置到一个特定的对象中

with （expression）statement 

定义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语句。
大量使用with语句会导致性能下降，同时也会给调试代码造成困难，因此不建议使用with语句。

switch 语句——将代码的作用域设置到一个特定的对象中

switch （expression）{
    case value：statement    //case：如果表达式等于value，就执行后面的语句statement；
        break；   //break：使代码执行流跳出switch语句。如果省break，导致执行完当前case后，会继续执行下一个case

    case value：statement
        break；

    case value：
        /*合并两种情形*/    //假如确实需要混合集中情况，不要忘了在代码中添加注释，说明是有意省略了break关键字。
    case value：statement
        break；

    ...
    default：statement    //default：在表达式不匹配前面任何一种情形时，执行机动代码（相当于else语句）
} 
switch语句中可以使用任何数据类型，每个case的值不一定是常量，可以是变量，甚至是表达式。

switch("hello world"){
case "hello"+" world":
alert("a");
break;
case "goodbye":
alert("b");
break;
default:
alert("c");
}

var num=25;
switch(true){   //之所以给switch语句传递表达式true，是因为每个case值返回一个布尔值
case num<0:
alert("num<0");
break;
case num>=0 && num<=10:
alert("num>=0 && num<=10");
break;
case num>=10 && num<=20:
alert("num>=10 && num<=20");
break;
default:
alert("num>=20");
}

注：switch语句在比较值时使用的是全等操作符，因此不会发生类型转换。

函数——ECMAScript函数使用function关键字来声明，后跟一组参数以及函数体。
function functionName（arg0，arg1，arg2，...，argN）{
    statement
}

ECMAScript中de函数在定义时不必指定是否返回值。实际上，任何函数在任何时候都可以通过return语句后跟要返回的值来实现返回值。
位于return语句之后的任何代码都永远不会执行。

一个函数中可以包含多个retrun语句。

function diff(a,b){ if(a<b){ return b-a; }else{ return a-b; }}
return语句可以不带有任何返回值，在这种情况下，函数在停止执行后将返回undefined。这种用法一般用在需要提前停止函数执行而又不需要返回值的情况下。推荐做法是要么让函数始终都返回一个值，要么永远都不要返回值。

函数参数

在函数体内可以通过arguments对象来访问这个参数数组，从而获取传递给函数的每一个参数。

arguments对象只是与数组类似（它并不是Array的实例），可以用方括号语法访问它的每一个元素arguments
，用arguments.length来确定传递进来多少个参数。

命名的参数只提供便利，但不是必需的。
arguments对象可以与命名参数一起使用。

还有一点比较有意思：arguments的值永远与对应命名参数的值保持同步。（它们的内存空间是独立的，但是值会同步）。如果只传入一个参数，arguments[1]设置的值不会反应到命名参数中。因为arguments对象的长度是由传入的参数个数决定的，不是由定义函数时命名参数的个数决定的。
没有传递值得命名参数将自动被赋予undefined值。

没有重载



ECMAScript中没有函数签名的概念，因为其参数是由包含零或多个值的数组来表示。因为没有函数签名，所以真正的重载是不能做到的。



如果在ECMAScript中定义了两个名字相同的函数，则该名字只属于后定义的函数。