一、JavaScript简介
JavaScript由Brendan Eich发明，于1995年出现在Netspace中（该浏览器已停止更新），并于1997年被ECMA（欧洲计算机制造商协会）采纳。
JavaScript与Java是两种不同的语言：Java是一门面向对象的编程语言，JavaScript是一门基于对象的编程语言。
JavaScript是一种轻量化的编程语言，是Web的基本编程语言，所有的现代化HTML页面都使用JavaScript，文件以.js为后缀。
1.JavaScript组成
一个完整的JavaScript实现应该由下列三个不同的部分组成：
语言核心（ECAMScript）
文档对象模型（DOM）
浏览器对象模型（BOM）由ECMA-262定义的ECMAScript与Web浏览器没有任何依赖关系，它只规定了这门语言的基础语法和概念部分（语法、类型、语句、关键字、保留字、操作符、对象。
2.JavaScript在HTML中的用法
使用script标签，有两种使用方式：直接在页面中嵌入JavaScript代码和包含外部JavaScript文件。
//直接在页面中嵌入JavaScript代码
<script>
alert("hello world");
</script>
//包含外部JavaScript文件
<script src="myStyle.js"></script>相比嵌入代码，外部文件有以下优点：可维护性；可缓存；适应未来。
注意：（1）一些老旧的示例可能会在<script>标签中使用type="text/javascript"，但是现在已经不必这样做了，因为JavaScript是所有现代浏览器和HTML5中的默认脚本语言。
（2）在使用<script>标签嵌入JavaScript代码时，不要在代码的任何地方出现"</script>"字符串，否则浏览器会报错，因为浏览器会认为那是结束的标签，可以通过转义字符"<\/script>"来解决。
（3）带有src属性的<script>元素不应该在其<script>和</script>标签之间包含额外的JavaScript代码。如果包含了嵌入的代码，则只会下载并执行外部脚本文件，嵌入的代码会被忽略。
（4）<script>标签的位置：可被放置在HTML页面的<body>和<head>部分中，或者同时存在于这两个部分。
3.<noscript>元素的使用
该元素用于在不支持JavaScript的浏览器中显示替代的内容。这个元素能够出现在文档<body>中的任何HTML元素（<script>）除外。包含在<noscript>元素中的内容只有在以下情况下浏览器才会显示<noscript>的内容：
1）浏览器不支持版本；2）浏览器支持版本，但是脚本被禁用了。
<html>
<head>
<title>DEMO1</title>
<script type="text/javascript" src="example1.js"></script>
<script src="example2.js"></script>
</head>
<body>
<noscript>
<p>本页面需要浏览器支持（启用）JavaScript。</p>
</noscript>
</body>
</html>这个页面会在脚本无效的情况下向用户显示一条信息。而在启用了脚本的浏览器中，用户永远也不会看到它--尽管它是页面的一部分。
总结：
A.JavaScript是一种专为网页交互而设计的脚本语言，包含以下三部分：
ECMAScript，由ECMA-262定义，提供核心语言功能。
文档对象模型（DOM），提供访问和操作页面内容的方法和接口。
浏览器对象模型（BOM），提供与浏览器交互的方法和接口。B.把JavaScript嵌入到HTML中要使用<script>元素，既可以将代码直接写在<script>与</script>标签之间，也可以使用src属性包含外部的JavaScript文件。
C.使用<noscript>元素可以指定在不支持脚本的浏览器中显示替代的内容，但在启用了脚本的情况下，浏览器不会显示<noscript>元素中的任何内容。
二、JavaScript基本概念
1.定义变量
ECMAScript的变量是松散类型的，所谓松散类型就是可以用来保存任何类型的数据。定义变量时要使用var操作符（var是一个关键字），后跟变量名 （即一个标识符）。在定义变量时，可以只声明而不初始化，也可以初始化：
var mes;//默认值是undefined
var meg="hi";
meg=100;//有效，但不推荐像mes这样，未经过初始化的变量，会保存一个特殊的值--undefined。 同时可以在修改变量值的同时修改变量类型。
注意：用var操作符定义的变量将成为定义该变量的作用域中的局部变量。也就是说，如果在函数中使用var定义一个变量，那么这个变量在函数退出后就会被销毁。
funtion test(){
var mes="hi";//局部变量，作用域在函数test()内部。
}
test();
alert(mes);//错误可以省略var操作符，从而创建一个全局变量：
funtion test(){
mes="hi";//全局变量
}
test();//只要调用一次test()，mes变量便有了定义，可以在函数外部的任何地方被访问到
alert(mes);//弹出"hi"2.标识符
所谓标识符，就是指变量、函数、属性的名字，或者函数的参数。标识符可以是按照下列格式规则组合起来的一个或多个字符：
第一个字符必须是一个字母、下划线(_)或一个美元符号($)
其它字符可以是字母、下划线、美元符号或数字通常来说，ECMAScript的标识符采用小驼峰命名规则。
3.数据类型
ECMAScript有5种简单（基本）数据类型：Undefined（未赋值）、Null（空）、Boolean（布尔）、Number（数字）和String（字符串）。还有一种复杂数据类型--Object（对象），Object本质上是由一组无序的名值对组成的。ECMAScript不支持任何创建自定义类型的机制，而所有值始终是上述6种类型之一。
注意：JavaScript变量均为对象。声明一个对象时，就创建了新的对象。
3.1 typeof操作符
用来检测给定变量的数据类型，对一个值使用typeof操作符可能返回下列某个字符串：
undefined--如果这个值未定义，或者定义后未赋值，或为undefined
boolean--如果这个值是布尔型
string--如果这个值是字符串
number--如果这个值是数值
object--如果这个值是对象或null
function--如果这个值是函数var message = "some string";
var obj = {a:"123"};
var func = function (){};
console.log(typeof(message)); // "string"
console.log(typeof(95)); // "number"
console.log(typeof(undefined)); // "undefined"
console.log(typeof(obj)); // "object"
console.log(typeof(null)); // "object"
console.log(typeof(false)); // "boolean"
console.log(typeof func); // "function"注意：typeof是一个操作符而不是一个函数，因此例子中的圆括号尽管可以使用，但不是必需的。
3.2 undefined类型
只有一个值，即特殊的undefined。在使用var声明变量但未对其加以初始化时，或者显示声明为undefined时，这个变量的值就是undefined。
var mes1;//值为undefined
var mes2=undefined;//值为undefined不过，包含undefined值的变量与尚未定义的变量还是不一样的。
对于尚未声明的变量，只能执行一种操作，即使用typeof操作符检测其数据类型。值得注意的是，对未初始化的变量执行typeof操作符会返回undefined值，而对未声明的变量执行typeof操作符同样也会返回undefined.
var mes3;
console.log(mes3);//"undefined"
console.log(mes4);//产生错误，提示mes4未定义。
alert(typeof mes3);//弹出"undefined"
alert(typeof mes4);//弹出"undefined"3.3 null类型
第二个只有一个值的数据类型，这个特殊的值是null。从逻辑角度来看，null值表示一个空对象指针，而这也是使用typeof操作符检测null值时会返回"object"的原因。
如果定义的变量准备在将来用于保存对象，那么最好将该变量初始化为null而不是其它值。这样一来，只要直接检查null值就可以知道相应的变量是否已经保存了一个对象的引用。
实际上，undefined值是派生null值得，因此对它们进行相等性检测会返回true。
var t=null;
alert(typeof t);//弹框"object"
if(t!=null){
//对t对象执行相应操作
}
alert(null==undefined);//true3.4 Boolean类型
只有两个值：true和false。
注意：Boolean类型的字面值true和false是区分大小写的。 即TRUE和False（以及其它的混合大小写形式）都不是Boolean值。
| 数据类型 | 转换为true的值 | 转换为false的值 |
| Boolean | true | false |
| String | 任何非空字符串 | ""(空字符串) |
| Number | 任何非零数字（包括无穷大） | 0和NaN |
| Object | 任何对象 | null |
| Undefined | n/a | undefined |
var message = "Hello world!";
if (message){ // ⾃动调⽤ Boolean 转换函数，返回对应的布尔类型值
alert("Value is true");
}3.5 Number类型
ECMAScript中定义了常用的数据类型有整数和浮点数，数值字面量格式包含八进制、十进制和十六进制。
注意 ：八进制字面值的第一位必需是0，后接八进制数字序列（0~7）。如果字面值的数值超过了范围，那么前导零将被忽略，后面的数值作为十进制数值解析。八进制字面量是在严格模式下是无效的，会导致JavaScript引擎抛出错误。
十六进制字面值的前两位必须是0x或0X，后跟任何十六进制数字（0~9及A~F）。其中，字母A~F也可以小写。
var intNum = 55; // 整数
var octalNum1 = 070; // ⼋进制的 56
var octalNum2 = 079; // ⽆效的⼋进制数值——解析为 79
var octalNum3 = 08; // ⽆效的⼋进制数值——解析为 8
var hexNum1 = 0xA; // ⼗六进制的 10
var hexNum2=01f;//31浮点数：
JavaScript中的浮点数前面可以没有整数，但是不推荐这种写法。
因为保存浮点数值需要的内存空间是保存整数值的两倍，因此，会将浮点数x.0转换为整数值x。
对于那些极大或极小的数值，可以用e表示法（即科学计数法）表示的浮点数值表示。用e表示法表示的数值等于e前面的数值乘以10的指数次幂。
默认情况下，ECMAScript会将那些小数点后面带有6个零以上的浮点数值转换为以e表示法表示的数值(例如，0.0000003->3e-7)
var a=1.1;
var b=0.2;
var c=.1;//有效，但不推荐
var floatNum1 = 1.; // ⼩数点后⾯没有数字：解析为 1
var floatNum2 = 10.0; // 整数：解析为 10
var floatNum1 = 3.125e7; // 等于31250000
var floatNum2 = 3e-7; // 等于0.0000003特别注意：由于ECMAScript使用了IEEE754浮点数格式，就会导致无法测试特定的浮点数值。
0.1 + 0.2 == 0.30000000000000004;
1.1 + 2.2 == 3.3000000000000003;因此，永远不要测试某个特定的浮点数值。
数值范围：
ECMAScript能够表示的最小数值保存在Number.MIN_VALUE中（在大多数浏览器中，该值为5e-324）；能够表示的最大数值保存在Number.MAX_VALUE中（在大多数浏览器中，该值为1.7976931348623157e+308）。如果某次计算的结果得到了一个超过JavaScript数值范围的值，那么这个数值将被转换为特殊的Infinity：如果是正数，则被转换为Infinity（正无穷）；如果是负数，则被转换为-Infinity（负无穷）。
可以用isFinite()函数确定一个数值是不是有穷的（换句话说，是不是位于最小和最大的数值之间），访问Number.NEGATIVE_INFINITY和Number.POSITIVE_INFINITY也可以得到负和正Infinity的值。
NaN（Not a number)：
一个特殊的数值，这个数值用于表示一个本来要返回数值的操作数未返回数值的情况。例如，在其它编程语言中，任何数值除以0会导致错误，从而停止代码执行。但在ECMAScript中，0除以0会返回NaN，正数除以0返回Infinity，负数除以0返回-Infinity，因此不会影响其它代码的执行。
NaN本身也有两个非同寻常的特点：任何涉及NaN的操作都会返回NaN；NaN与任何值都不相等，包括NaN本身。
alert(NaN==NaN);//falseECMAScript定义了isNaN()函数，这个函数接受一个参数，该参数可以是任何类型，而函数将会帮我们确定这个参数是否”不是数值“。isNaN（）在接受到一个值后，会尝试将这个值转换为数值。某些不是数值的值会直接转换为数值。
alert(isNaN(NaN));//true
alert(isNaN(10));//false（10是一个数值）
alert(isNaN("10"));//false（可以被转换为数值10）
alert(isNaN(""));//false(可以被转换为0）
alert(isNaN("blue"));//true（不能被转换为数值）
alert(isNaN(true));//false（可以被转换为数值1）isNaN()也适用于对象。在基于对象调用isNaN()时，会首先调用对象的valueOf()，然后确定该方法返回的值是否可以转换为数值。如果不能，则基于这个返回值再调用toString()方法，再测试返回值。
4.js的类型转换函数
Number()：用于任何数据类型
parseInt()：专门用于字符串转换成数值
parseFloat()：专门用于字符串转换为数值Number()的转换规则：
Number()转换规则：
如果是数字值，只是简单的传入和返回。
如果是Boolean值，true和false将分别被转换为1和0.
如果是null值，返回0.
如果是undefined，返回NaN
如果是字符串，遵循以下规则：
如果字符串中只包含数值（包括前面带正号或负号的情况），则将其转换为十进制数值，即"1"会变成1，"123"会变成123，而"011"会变成11.
如果字符串中包含有效的浮点格式，如"1.1",则将其转换为对应的浮点数值(同样，也会忽略前导0）
如果字符串是有效的十六进制格式，如"0xf"，则将其转换为相同大小的十进制整数值。
如果字符串是空的（不包含任何字符），则将其转换为0.
如果字符串中包含除上述格式之外的字符，则将其转换为NaN。
如果是对象，则调用对象的valueOf()，然后按照前面的规则转换返回的值。如果转换的结果是NaN，则调用对象的toString()，然后再次依照前面的规则转换返回的字符串值。
var num1=Number("Hello");//NaN
var num2=Number("");//0
var num3=Number("000011");//11
var num4=Number(true);//1parseInt()的转换步骤如下：
1.忽略字符串前面的空格，直至找到第一个非空格字符；
2.如果第一个字符不是数字字符或者负号，parseInt()就会返回NaN;
3.如果第一个字符是数字字符，parseInt()会继续解析第二个字符，直到解析完所有后续字符或者遇到了一个非数字字符。
注意：可以为这个函数提供第二个参数，即转换时使用的基数（即多少进制）。
var num1=parseInt("1234red");//1234
var num2=parseInt("");//NaN
var num3=parseInt("0xA");//10
var num4=parseInt(22.5);//22
var num5=parseInt("70");//70
var num6=parseInt("0xf");//15
var num7=parseInt("0xAF",16);//175parseFloat()的转换步骤如下：
1.从第一个字符（位置0）开始解析每个字符。
2.一直解析到字符串末尾，或者解析到遇见一个无效的浮点数字字符为止。
3.字符串中的第一个小数点是有效的，而第二个小数点就是无效的了。
4.始终忽略前导的零。parseFloat只解析十进制，没有通过第二个参数指定基数的用法。十六进制格式的字符串则始终会被转换为0.
5.如果字符串包含的是一个可解析为整数的数（没有小数点，或者小数点后都是零），parseFloat()会返回整数。
var num1=parseFloat("123yellow");//123
var num2=parseFloat("0xA");//0
var num3=parseFloat("22.5");//22.5
var num4=parseFloat("22.34.5");//22.34
var num5=parseFloat("0908.5");//908.5
var num6=parseFloat("3.125e7");//31250000string类型->整数 parseInt(变量名)
注意：转换的时候，遇到非数值类型字符的时候就停止了。
如果在转换的时候，字符以非数值的数据开始，那么停止转换，值：NAN（none and none),没有数据。
eg:var a="10";
a=parseInt(a);
document.write("a的类型是："+typeof(a)+"<br/>);
string类型->小数 parseFloat(变量名);
js:string类型和number类型比较，先将string类型转换为对应的number类型，然后再进行比较。
常用的函数：
document.write();//通过文档对象输出
Window.alert("消息对话框");
typeof(变量名):查看类型5.注释
//--单行注释
/*
*
*
*/--多行（块级）注释6.严格模式
严格模式（strict mode）定义了一种不同的解析与执行模型。在严格模式下，JavaScript中的一些不确定的行为将得到处理，而且对某些不安全的操作也会抛出错误。要在整个脚本文件中启用严格模式，可以在顶部添加如下代码：
// "use strict";在函数内部的上方包含这条编译指示，也可以指定该函数在严格模式下执行：
function doSomething(){
"use strict";
//函数体
}7.语句
JavaScript中的语句以一个分号结束，也可以省略分号，由解析器确定语句的结尾。虽然语句结尾的分号不是必需的，但建议任何时候都不要省略它。
三、JavaScript运算符
1.算术运算符：+，-，*，/
2.比较运算符：<,>,<=,>=...
3.逻辑运算符：逻辑非：！ 逻辑与：&，&& 逻辑或（|，||）
4.三目（元）运算符 表达式?true的结果:false的结果
注意：js是弱类型语言，true-->1 false-->01.递增和递减操作符不仅适用于整数，还可以适用于字符串、布尔值、浮点数值和对象。在应用于不同值时，应遵循以下规则：
在应用于一个包含有效数字字符的字符串时，先将其转换为数字值，再执行加减1的操作。字符串变量变成数值变量。
在应用于一个不包含有效数字字符的字符串时，将变量的值设置为NaN，字符串变量变成数值变量。
在应用于布尔值false时，先将其转换为0再执行加减1的操作。布尔值变量变为数值变量。
在应用于布尔值true时，先将其转换为1再执行加减1的操作。布尔值变量变为数值变量。
在应用于浮点数值时，执行加减1的操作。
在应用于对象时，先调用对象的valueOf()方法以取得一个可供操作的值，然后对该值应用前述规则。如果结果时是NaN，则再调用toString()再应用前述规则。对象变量变成数值变量。
2.一元加和减操作符
一元加操作符以一个加号(+)表示，放在数值前面，对数值不会产生任何影响。不过，在对非数值应用一元加操作符时，该操作符会像Number()转型函数一样对这个值执行转换。
将一元减操作符应用于数值时，该值会变成负数。应用于非数值时，一元操作符遵循与一元加操作符相同的规则，最后再将得到的数值转换为负数。
var s1="01";
var s2="1.1";
var s3="z";
var b=false;
var f=1.1;
var o={
valueOf:function(){
return -1;
}
};
s1=+s1;//1
s2=+s2;//1.1
s3=+s3;//NaN
b=+b;//0
f=+f;//1.1
o=+o;//-1
s1=-s1;//-1
s2=-s2;//-1.1
s3=-s3;//NaN
b=-b;//0
f=-f;//-1.1
o=-o;//1注意：递增递减操作符和一元操作符作用于非数值的变量时，都会隐式地调用Number()函数，区别在于递增递减操作符改变的是变量本身，而一元加减操作符不会改变变量自身的值。
3.布尔操作符
3.1 逻辑非
应用于任何值，无论这个值是什么数据类型，这个操作符都会返回一个布尔值。
运算规则：首先将它的操作数转换为一个布尔值，然后对其求反。
| 操作数 | 返回值 |
| 对象 | false |
| 空字符串 | true |
| 非空字符串 | false |
| 0 | true |
| 任意非0数值 | false |
| null | true |
| NaN | true |
| undefined | true |
3.2 逻辑与(&&)
逻辑与操作可以应用于任何类型的操作数，而不仅仅是布尔值。在有一个操作数不是布尔值的情况下，逻辑与操作就不一定返回布尔值。此时，它遵循以下规则：
| 操作数 | 返回值 |
| 第一个操作数是对象 | 第二个操作数 |
| 第二个操作数是对象 | 只有在第一个操作数的求值结果为true的情况下才会返回该对象。 |
| 两个操作数都是对象 | 第二个对象 |
| 有一个操作数是null | null |
| 有一个操作数是NaN | NaN |
| 有一个操作数是undefined | undefined |
注意：逻辑与操作属于短路操作，即如果第一个操作数就能决定结果，那么就不会再对第二个操作数求值。对于逻辑与操作而言，如果第一个操作数是false，则无论第二个操作数是什么值，结果都不再可能是true了。
3.3 逻辑或(||)
如果有一个操作数不是布尔值，逻辑或也不一定返回布尔值。此时，它遵循以下规则：
| 操作数 | 返回值 |
| 第一个操作数是对象 | 第一个操作数 |
| 第一个操作数的求值结果是false | 第二个操作数 |
| 两个操作数都是对象 | 第一个操作数 |
| 两个操作数都是null | null |
| 两个操作数都是NaN | NaN |
| 两个操作数都是undefined | undefined |
注意：逻辑或操作符也是短路操作符。如果第一个操作数的求值结果为true，就不会对第二个操作数求值了。
4.乘性操作符(+、-、%)
在操作数为非数值的情况下会执行自动的类型转换。如果参与乘性计算的某个操作数不是数值，后台会先使用Number()转型函数将其转换为数值。也就是说，空字符串会被当作0，布尔值true将被当作1.
alert(2*"");//0
alert(true*5);//5
alert(5/2);//2.5
alert(5%2);//1注意：求商运算符("/")在C语言中， 5/2的结果是2，而在JavaScript中5/2的结果是2.5.
5.加性操作符(+、-)
加法根据以下规则返回结果：
如果有一个操作数是NaN，则结果是NaN；如果是Infinity加-Infinity，则结果是NaN；如果两个操作数都是字符串，则将第二个操作数与第一个操作数拼接起来；如果只有一个操作数是字符串，则将另一个操作数转换成字符串，然后再将两个字符串拼接起来；对于undefined和null，则分别调用String()函数并取得字符串"undefined"和"null"。
var res1=5+5;//10
var res2=5+"5";//"55"
var num1=5;
var num2=10;
var mes="The sum of 5 and 10 is "+num1+num2;//"The sum of 5 and 10 is 510"减法根据以下规则返回结果：
如果有一个操作数是NaN，则结果是NaN；如果是Infinity减Infinity，则结果是NaN；如果有一个操作数是字符串、布尔值、null或undefined，则先在后台调用Number()函数将其转换为数值，然后再根据前面的规则执行减法计算。如果转换的结果是NaN，则减法的结果是NaN。
var res1=5-true;//4
var res2=NaN-1;//NaN
var res3=5-3;//2
var res4=5-"";//5
var res5=5-"2";//3
var res6=5-null;//5
var res7=1-undefined;//NaN6.关系操作符(<,>,<=,>=)
返回的是布尔值。关系操作符既可以作用于两个数字，也可以作用于其它类型的数据。当关系操作符的操作数使用了非数值时，也要进行数据转换或完成某些奇怪的操作。规则如下：
如果两个操作数都是数值，则进行数值比较；如果两个操作数都是字符串，则比较两个字符串对应的字符编码值；如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较；如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较；如果一个操作数是对象，则调用这个对象的valueOf()方法，用得到的结果按照前面的规则执行比较。如果对象没有valueOf()方法，则调用toString()方法，并用得到的结果根据前面的规则执行比较。
var res1=5>3;//true
var res2=5<4;//false
var res3="Brick"<"alphabet";//true
var res4="Brick".toLowerCase()<"alphabet".toLowerCase();//false
var res5="23"<"3";//true
var res6="23"<3;//false
var res7="a"<3;//false，因为"a"被转换为了NaN注意：a.在比较字符串时，实际比较的是两个字符串中对应位置的每个字符的字符编码值，大写字母的字符编码全部小于小写字母的字符编码。b.任何操作数与NaN进行关系比较，结果都是false。
7.相等操作符
7.1 相等和不相等（==和!=）
这两个操作符会先转换操作数（通常称为强制转换），然后再比较它们的相等性。在转换不同的数据类型时，相等和不相等操作符遵循以下基本规则：
如果有一个数是布尔值，则在比较相等性之前先将其转换为数值（false转换为0，true转换为1）；如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值。
注意：null和undefined是相等的；在比较相等性之前，不能将null和undefined转换成其它值；如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象（内存地址相同），则相等操作符返回true，否则返回false。
| 表达式 | 值 |
| null==undefined | true |
| "NaN"==NaN | false |
| 5==NaN | false |
| NaN==NaN | false |
| NaN!=NaN | true |
| false==0 | true |
| true==1 | true |
| true==2 | false |
| undefined==0 | false |
| null==0 | false |
| "5"==5 | true |
7.2 全等和不全等
全等和不全等在比较之前不转换操作数，所以只有在两个操作数相等且类型相同的情况下，才全等。这是一种更严格的比较方式，推荐使用。
var res1=("55"==55);//true，因为转换后相等
var res2=("55"===55);//false，因为不同的数据类型不相等使用说明：由于相等和不相等操作符存在类型转换问题，而为了保持代码中数据类型的完整性，推荐使用全等和不全等操作符。
8.逗号操作符
使用逗号操作符可以在一条语句中执行多个操作，用于声明多个变量或者赋值。在用于赋值时，逗号操作符总会返回表达式的最后一项:
var num1=1,num2=2,num3=3;//声明多个变量
var num=(5,1,2,4,0);//num的值是0四、JavaScript流程控制语句
1.顺序结构语句
2.选择结构语句
if...else..
Java中的switch语句：case后面只能是常量，不能跟变量。
JavaScript中的switch语句：case后面的值既可以是常量，也可以是变量,还可以是表达式。
switch语句的条件：
1)遇到break结束。2）程序默认执行到末尾。
case穿透：遇见break结束，如果没有break，就会出现这种情况。
switch(表达式){
case 值1:
语句1；
break;
case 值2:
语句2；
break;
.........
default:
语句n+1;
break;
}
3.循环结构语句：for while do...while...
for(初始化语句;条件判断；步长语句){
循环体语句;
}
初始化语句;
while(条件判断){
循环体语句;
步长语句；
}
do-while语句：和for、while语句区别：do-while至少执行一次。
初始化语句;
do{
循环体语句；
步长语句;
}while(条件判断）;
注意：js中，表达式可以是数据类型：
number类型：非0的数据，条件成立。
string类型：非空字符串，条件成立；否则不成立。
boolean类型：true，成立；否则不成立。
object类型：非null类型的对象，条件成立；否则不成立。
var age=20;
switch(age){
case age>18:
document.write("成年人"+"<br/>");
break;
default:
document.write("成年人"+"<br/>");
break;
}
4.for-in语句
js中的for-in语句类似于Java中foreach语句，Java中foreach语句：增强for用来替代iterator。
格式：for(var 变量名 in 数组名称/具体的对象名称）{
输出变量:数组名称[变量名];
}
如：
定义一个数组
var arr=[10,20,30,40];
普通for循环
for(var i=0;i<arr.length;i++){
document.write(arr[i]+"<br/>");
}
document.write("<br/>");
for-in循环
for(var i in arr){
alert(arr[i]);//弹出
}
//定义对象：使用function 对象（形式参数）{}
function Person(name,age){//不能写参数类型
this.name=name;//this代表当前Person对象地址值
this.age=age;
}
var定义对象
var p=new Person("张三",20):
//遍历p的属性
for(var j in p){
document.write(p[j]+"<br/>");
}
6.with语句
//浏览器中显示：*形
*
**
***
****
*****
for(var i=0;i<5;i++）{
for(var j=0;j<i;j++){
document.write("* ");
}
document.write("<br/>");
}
with语句的格式：
with(document/对象类型）{
语句;
}
with(document){
for(var i=0;i<5;i++）{
for(var j=0;j<i;j++){
write("* ");
}
write("<br/>");
}
}五、JavaScript函数
定义格式：
function 函数名称（形式参数列表){
语句;
}
定义函数注意事项：
1）函数中的形式参数不能带var定义。
2）定义函数可以不带返回值：function 函数名（）{}
3）在js中，没有方法重载的概念，后面定义的同名的函数会将前面的函数覆盖掉。
形式参数列表 实际参数列表
//形式参数列表大于实际参数：NAN
//形式参数列表小于实际参数：将通过arguments数组，将前面的数据进行一一绑定，将多余的实际参数去除掉。
4）函数中存在一个隐藏的数组：arguments数组，作用就是将实际参数和形式参数一一绑定。
funciton add(a,b){
//可以不带return语句
document.write("两个数据之和是："+(a+b));
//带return语句
return (a+b);
alert(arguments.length);
for( var i=0;i<arguments.length;i++){
alert(arguments[i]);
}
}
funciton add(a,b,c){//形式参数列表大于实际参数：NAN
document.write("数据之和是："+(a+b+c));
}
调用函数：
单独调用
函数名称（实际参数列表）；
add(10,20);
赋值调用
带return语句函数的调用
var res=add(10,20);
656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
