韩顺平+传智2015js笔记完整版(史上最全的js笔记)
JavaScript基础总结 (3)
一．JavaScript简介 (3)
1.定义 (3)
2.出现背景 (3)
3. 语法规范 (4)
二．变量 (4)
1. 定义 (4)
2. 数据类型 (5)
3. 运算符 (6)
4. 字符串运算符 (7)
5. 比较运算符 (8)
6. 逻辑运算符 (8)
7. 位运算符 (10)
8.运算符的优先级： (12)
三．流程控制 (12)
1.if条件语句控制流程 (12)
2.switch分支结构 (13)
3.while循环结构 (15)
4.do while循环结构 (15)
5.for循环结构 (15)
6. return两个关键字break和continue (17)
四．函数 (18)
1. 基本感念 (18)
2.函数的定义形式： (18)
3. 函数的调用形式： (18)
7. 全局变量与局部变量 (27)
8. JavaScript系统内部函数(类) (28)
五．数组 (34)
1.数组的定义： (34)
2.数组和对象的比较： (34)
3.对数组的形象化理解： (34)
4.数组遍历形式 (35)
5.二维数组： (36)
6.数组常用方法： (36)
7.Array系统内部类 (38)
六．JavaScript面向对象 (40)
1. 澄清概念 (40)
2. 创建对象 (41)
3. 对象的引用及内存分配 (43)
4.JavaScript中一切都是对象 (44)
5. 访问对象的属性2种方法 (45)
6. this关键字详解 (45)
7. 成员方法 (51)
8. 面向对象的三大特性 (54)
9.JS的函数重载和重写的问题 (62)
10. 静态成员 (64)
11. 异常处理 (65)
七．作用域链 (66)
1. 定义 (66)
2. 作用域链的作用 (67)
3. AO活动对象 (69)
4.执行环境可以访问变量的类型及优先顺序 (70)
八．闭包 (70)
1. 什么是闭包 (70)
2. 闭包特点 (71)
3. 闭包使用规则 (71)
4. 闭包案例 (71)
九．事件操作 (74)
1. 网页对象简介 (74)
2. 设置事件 (75)
3.事件流 (78)
4.事件操作 (79)
5.事件对象 (86)
6.找对象方法大全 (103)
十．DOM (103)
1.DOM介绍 (103)
3. DOM常见属性 (105)
4.DOM对属性值的操作 (112)
5.DOM对css样式操作 (114)
6.DOM常用方法: (115)
7. 常用到的DOM对象 (115)
8.BOM (121)
十一．正则表达式 (122)
1.概念 (122)
2.作用 (123)
3.创建形式 (123)
4.用到的函数及对象 (123)
5.定义字符集案例说明 (128)
6.特别字符案例说明 (129)
7.模式修正符组成 (134)
8.()小括号使用 (136)
9.组合和限制字符案例说明 (138)
10.正向反向预查 (141)
JavaScript 基础总结
一．JavaScript 简介
1.定义
基于事件和对象驱动，并具有安全性能的用于WEB 开发的脚本语言。 JavaScript 属于弱数据类型语言。
脚本语言：
1）脚本语言往往不能独立使用，它和HTML/JSP/PHP/https://www.wendangku.net/doc/928542934.html, 配合使用 2）脚本语言也有自己的变量，函数，控制语句（顺序，分支，循环）
3)脚本语言实际上是解释性语言（即在执行时直接对源码进行执行），编译性语言效率会更高一些 4)Java 程序.java→.class→jvm ,js→浏览器（js 引擎来解释执行） 5)Js 主要在客户端（浏览器）执行
6)因为js 是由浏览器来执行的，因此这里有个问题，不同类型的浏览器可能对js 的支持不一样。 7)开发工具的选择：记事本 myeclipse
2.出现背景
上世纪90年代，在美国有出现，当时有上网的环境，并且有网站服务在运行。 注册服务
上图涉及的问题：
① 带宽非常浪费，往往由于一个项目部正确，其他项目被反复提交给服务器 ② 用户体验不好，反复填写表单域信息，项目不正确，页面会刷新。 ③ 用户等待时间比较长，带宽非常小，每次提交动作占用时间长。
针对以上问题，网景公司发明了javascript 语言，最初用于在客户端对表单域项目进行验证。
网景公司在1995年发布了javascript 语言，起初名字为livescript ，在发布的前夕该名字为javascript,与sun 公司的java 语言打一个擦边球，这个决定也使得网景后期得到许多商业回报。 微软公司也有自己的脚本语言，名字为Jscript （是javascript 的拷贝版本）
客户端(浏览器) 用户名 密码 邮箱 手机号码 性别 身份号码
注册
服务
器
(apache/mysql/php)
验证
表单提交
验证失败，返回
3.语法规范
①在html代码里边引入js语言
②代码大小敏感
true/false
TRUE/FALSE
③结束符号
每个简单语句使用”;”结束，与php类似
在javascript里边，该分号不是必须，但是推荐使用
④注释
// 单行注释
/*多行注释*/
⑤js语言区分大小写。
二．变量
1.定义
变量就是一个内存区块的名字。该区块可以存储我们的“东西”（内容）——数据。
变量几乎是“无穷无尽”——从手写的角度来说，可以定义任意多个变量。
一个变量里面只能存一个数据
①变量的基本形式
1）以var关键字生命变量；
2）变量由变量名和变量值组成；
——变量名应该遵循我们的命名规则：
php里边：字母、数字、下划线组成，开始有$符号标志，数字不能作为开始内容
js里边：字母、数字、下划线、$符号、汉字等5个组成部分，数字不能作为名字
a.以字母或下划线开头，
b.后面可以跟若干个字母，数字和下划线。
②变量赋值的标准形式：
变量名 = 某个值；
——赋值就是将一个值放到一个变量所代表的内存空间中。
变量定义和赋值常常使用如下复合形式：
var 变量名 = 某个值；
举例：
var i = 3;
var j = 4;
var s = i + j; //此时s是定义的同时也赋值，且其值是两个变量想加的结果。
a.赋值传值：也叫拷贝传值，值传递。其含义是：将有个变量的值拷贝一份，然后放入另一个变量中。此时，两个变量是互相独立的，没有任何直接关联。
——对js，基本数据类型（和2个特殊类型）使用值传递。
b.引用传值：也叫地址传值，引用传递。其含义是：将一个变量的地址拷贝一份，然后让人另一个变量中。实际上，此时这两个变量对对应了一个实际的“对象”
——对js，符合数据类型使用引用传递。
2.数据类型
①三种基本数据类型：
1）数字型（number）：表示一个数字，比如3， 2.7， 1.342e6——数字几乎是无穷无尽的
a.进制数的表示
十进制： var age = 23;
八进制： var score = 023; 2*8+3=19的十进制数
十六进制： var color = 0x25; 2*16+5=37的十进制数(10:A 11:B 12:C 13:D 14:E 15:F)
//十进制数
var age = 20;
//alert(age);
//document.write(age);
//console.log()是浏览器调试工具(firebug)的输出工具
// 对信息的输出比较全面，例如可以输出对象的成员属性、成员方法等
console.log(age);
//八进制数
console.log(032); //3*8+2 = 26
console.log(0524); //5*8*8+2*8+4 = 340
console.log(07415); //7*8*8*8+4*8*8+1*8+5 = 3853
console.log(059); //59 保持原值
console.log(081); //81 保持原值
//十六进制
console.log(0x24); //2*16+4 = 36
console.log(0xC6); //12*16+6 = 198
console.log(0xFD5); //15*16*16+13*16+5 = 4053
//计算不准确
console.log(0.1+0.2);//0.30000000000000004
console.log("-------------");
console.log(Number.MAX_VALUE);//1.7976931348623157e+308 等于 1.79*10的308次方
console.log(Number.MIN_VALUE);//5e-324 等于 5*10的-324次方(5除以10的324次方 0.000..005)
b.浮点数
//浮点数
console.log("-------------");
console.log(12.345); //12.345
console.log(0.87); //0.87
console.log(.87); //0.87
console.log(34.0); //34
c.最大数，最小数
最大：Number.MAX_VALUE;
最小：Number.MIN_VALUE;
d. 无穷大的数
//无穷大的数
console.log(Number.MAX_VALUE + Number.MAX_VALUE);//Infinity
console.log(10/0);//Infinity
2）字符型（string）：表示一个字符，形式上要使用引号(‘’或””都行)引起来。字符串也几乎是无穷无尽的。比如：
“abc”, “传智播客”‘def’“12345”“3+4=7”“var i=3”
var v1 = “abc”;
var v2 = ‘12345’;
3）布尔型（boolean）：表示一个“真假”的结果，只有两个可用的值：true，false
var v1 = true;
var v2 = false;
②两种特殊类型：
1）空类型（null）表示一个变量中的值是“没有”——此类型只有一个值null
var s = null;
2）未定义类型（undefined） : 表示一个变量的值没有定义（即没有给值）—此类型也只有一个值var s ; //此时s的类型就是undefined，且其值也是undefined
③两种复合类型：
1）数组：多个数据的有序排列而成的一个整体。
var s = [ 3, 2.2, “abc”, true ];
2）对象：多个数据的所组成的一个整体
var s = { a:3, b:2.2, k:”abc”, mm:true }
④js数据类型转换：
1)自动转换
例子：var a=123; //a是数值 a=”hello” //a的类型是string
2)强制转换
例子：字符串转换成数字
var a="123” ;
a=parseInt(a); //使用系统函数强制转换
var b=90 ; //b是number
b=b+””, //b就是string
3.运算符
1)算术运算符
+ - * / % ++ --
%: 取模运算，也可以叫做求余运算——求两个整数相除之后的余数。注意：只对整数有效。
var s1 = 7 % 2; //结果是1
var s2 = 11 % 3; //2
var s3 = 15 % 5；//0
var s4 = 2%8; //2(比除数小的就等于被除数本身)（x%8）//x [x<8]
++或--：自加(减)运算符。该运算符称为“单目运算符”，即只要一个变量就可以运算，其含义是：对该变量“自增1”，同样只针对整数。
a++ //a=a+1
b-- //b=b-1
++a 表示先把自己加1再赋值
--a 表示先把自己减1再赋值
//i++ ++i在没有赋值给第二个变量或是执行在函数里的时候没有区别
var score = 90;
//score++;//91
++score;
console.log(score); //91
//i++ ++i 有赋值的时候，使用区别如下：
var age = 20;
//var new_age = age++; //先返回信息，再++计算
//console.log(new_age+"---"+age); //20---21
var new_age = ++age; //先++计算，再把结果返回
//console.log(new_age+"---"+age); //21---21
在函数里执行时：
//例1：
var a=0;
window.alert(a++);先执行alert(a)；再执行a=a+1;[输出结果为0]
//列2:
Window.alert(++a);先执行a=a+1;再alert(a);[输出结果为1]
无限循环8次技巧；
var n =1;
(n++%8)+1
4.字符串运算符
理论上的字符串运算符只有1个，那就是加号“+”。其含义是：将两个字符串“串连起来”成为一个新的“更长”的字符串。
这里要跟算术运算符“＋”相区分：
在加号“+”的任意一边只要有一个是字符串，则该符号就是字符串相加了（如果另一个不是字符串，则会自动转换为字符串后再相连接）
var v1 = 1;
var v2 = 2.2;
var v3 = “3.3”;
var s1, s2, s3, s4;
s1 = v1 + v2; //3.2
s2 = v1 + v3; //“13.3”
衍生出的字符串运算符：
+=其含义是：对某字符串自身加上指定的新内容。
var s = “abc”;
s += “def”; //”abcdef”, 相当于 s = s + “def”
5.比较运算符
用于比较两个数据（变量）的大小关系，有：
>>= <<= ==(等于) !=(不等于) ===（全等于）！==（不全等于）比较运算符运算的结果只有两个情况： true, false
var v1 = 5;
var v2 = 6;
var v3 = v1 > v2; //false;
var v4 = v2 > v1; //true
var v5 = v1 < v2; //true
var v6 = v2 <= v1; //false;
实际应用中，其实常常类似这样：
if（v1 > v2） {
…………………………………..
}
else
{
…………………………….
}
*注意：JS中字符串比较也要用==
一旦找到了一个满足条件的入口，执行完毕后，就直接结束整个多分支
补讲== 号的作用
a.当== 的两边都是字符串的时候，则比较内容相等否。
b.如== 的两边都是数字的时候，则数的大小是否相等。
c.如== 的两边是对象或对象中的函数属性，则比较地址是否相等。
6.逻辑运算符
逻辑运算符只针对布尔值进行运算，运算的结果还是布尔值。
逻辑运算符有3个：
1）与运算：符号： &&
var b1 = true;
var b2 = false;
var b3 = b1 && b2; //…….这里最终只有4种情况，2个结论
与运算的真值表：（概况了所有可能的与运算）
b1 && b2 b1 = true b1 = false
b2 = true b1 && b2; → true b1 && b2; → false
b2 = false b1 && b2; → false b1 && b2; → false
逻辑与运算的图示：
可见，逻辑与运算的原理是串连电路原理。
2）逻辑或运算符：符号 ||
含义：两个条件只要有一个满足，结果就是满足（true）
或运算的真值表：（概况了所有可能的或运算）
b1 || b2 b1 = true b1 = false
b2 = true b1 || b2; → true b1 || b2; → true b2 = false b1 || b2; → true b1 || b2; →false
或运算的示意图（原理是并联电路）：
3）逻辑非运算符：符号： !
含义：取相反值。
var v1 = true;
var v2 = !v1; //v2此时是false
var v3 = !v2; //此时 v3为true
//总结：// ||一真则真; // &&一假则假
var a = 10;
var b = 20;
var c = 30;
var name = "tom";
var age = 23;
var money = 0;
//字符串和数值信息进行逻辑运算符
//期间它们要进行数据类型转换
//0 "" array() null 等信息都被转换为false信息
//① &&和||的结果是其中一个操作数
console.log(name && age); //23 决定整体结果的操作数作为最终结果体现
console.log(age && money); //0
console.log(name || money); //tom
console.log(a>5 && b>10);//true，是b>10的结果
//② !取非最终是布尔结果
console.log(!name); //false
console.log(!money); //true
*特别说明：在逻辑运算中：0，””，false，null，undefined，NaN均表示false
除了这些均表示真的。
var a=0;
if(!a){
window.alert(“OK”);
}
输出OK
4）短路运算
只给执行一个操作数，不执行另一个操作数，不被执行的操作数就被短路。
var name = "tom";
var age = 23;
var money = 0;
console.log(name || money); //【tom】money被name给短路
console.log(money && age); //【0】age被money给短路了
//console.log(name && alert(123));//【undefined】
console.log(age || alert('hello')); //alert()被age给短路
7.位运算符
基本要求；位运算是只针对整数的二进制而进行的。
数值二进制表示（只讨论8个位即一个字节的情况）
v1 = 1 0 0 0 0 0 0 0 1
v2 = 3 0 0 0 0 0 0 1 1
v3 = 7 0 0 0 0 0 1 1 1
v4 = 12 0 0 0 0 1 1 0 0
v4 = 12 = 8 + 4 = 1000(2) + 100(2) = 1100(2);
v5 = 87 = 64 + 23 = 64 + 16 + 4 + 2 + 1 = 1000000(2) + 10000(2) + 100(2) + 10(2) + 1(2) = 1010111
按位左移运算：符号： <<
含义：将数据的二进制表示形式上的每一个位上的数字往左边移动指定的位数，右边空出部分补０，
左边冒出部分不管。
格式：数据 << 位数；
举例：
var v4 = 12；
var s1 = v4 << 2;
图示运算原理：
数值二进制表示（只讨论8个位即一个字节的情况）
v4 = 12 0 0 0 0 1 1 0 0
s1 = v4 << 2 0 0 1 1 0 0 0 0
0 0 25→32 24→16 0 0 0 0
s1 = 32+16 =
48
s2 = v4 >> 2 0 0 0 0 0 0 1 1
按位右移运算：符号： >>
含义：将数据的二进制表示形式上的每一个位上的数字往右边移动指定的位数，左边空出部分补０，
右边冒出部分不管。
格式：数据 << 位数；
实际上，左移运算就是“乘2”运算，左移几位就乘几次2
左移运算就是“除2”运算，右移几位就除几次2
位运算的其他运算符：
按位与：符号 &
含义：两个数对应二进制位上的数字（0或1）进行位与运算（1&1=>1,1&0=>0,0&1=>0,0&0=>0）.结
果值为每一位运算结果后的所有数字结果。
数值二进制表示（只讨论8个位即一个字节的情况）
v4 = 12 0 0 0 0 1 1 0 0 v5 = 9 0 0 0 0 1 0 0 1
0 0 0 0 1 0 0 0 s1 = v4 & v5
→ 8
按位或：符号： |
含义：两个数对应二进制位上的数字（0或1）进行位或运算（1|1=>1,1|0=>1,0|1=>1,0|0=>0）.
结果值为每一位运算结果后的所有数字结果。
按位非： ~
按位异或： ^
8.运算符的优先级：
运算表达式中的小括号的作用：跟数学上完全一致，就表示“优先运算”，例：
var s = (-b + b*b – 4*(a+3)*c ) / (2*a*c)
对运算符的优先级，我们需要记住以下几条规则：
1，要意识到运算符有先后顺序问题（正如数学上的运算符优先）
2，括号最优先
3，赋值最落后。
4，先乘除后加减
三．流程控制
顺序结构: 对编程而言，不控制其流程就是顺序执行
分支选择结构: if elseif switch
循环结构: while() do{}while() for()
1.if条件语句控制流程
单分支：
if( 条件判断) //条件判断的结果只有2个：true，false
{//语句块}
双分支(二选一分支形式)：
if( 条件判断) //条件判断的结果只有2个：：true，false
{//语句块1}
else
{//语句块2}
多分支：
if( 条件判断1 ) //如果条件判断1成立，则执行语句块1，其他就不执行了。
{//语句块1}
else if (条件判断2 ) //如果，条件判断1不成立，则继续判断条件2，如果成立，则执行语句块2，{//否则继续后面的判断，依此类推//语句块2}
else if (条件判断3 )
{//语句块3}
。。。。。。。。。。。。。。。。。。。。。
最完整形式：
if( 条件判断1 ) //如果条件判断1成立，则执行语句块1，其他就不执行了。
{
//语句块1
}
else if (条件判断2 ) //如果，条件判断1不成立，则继续判断条件2，如果成立，则执行语句块2，{ //否则继续后面的判断，依此类推
//语句块2
}
else if (条件判断3 )
{
//语句块3
}
………………………
else //如果前面所有的if判断都不成立，就会执行本语句块
{
//最后的语句块
}
案例：如果是男同志，上男厕所，女同志上女厕所，否则不上厕所
var sex= window.prompt("请输入性别");
if(sex=="男"){
window.alert("上男厕所");
}else if(sex=="女"){
window.alert("上女厕所");
}else{
window.alert("不上厕所");
}
2.switch分支结构
switch其实也是实现类似if语句的多分支结构。在该结构中，也是最终顶多会执行其中的一个语句块。
switch ( 一个变量或表达式exp ) //这里，不管是变量还是表达式，其实最终都应该是一个“值”{
case 对比值v1：// 如果exp的值等于当前v1的值，则执行本语句块。
// 这里的“值v1”通常只用3种基本数据类型
//语句块1；
break; //碰到本break语句，会立即跳出switch结构，执行该结构之后的其他语句
case 对比值v2：//如果前面exp不等于v1，则继续判断exp是否等于v2，
//如果相等，则执行语句块2
//语句块2
break;
。。。。。。。。。。。。。。。。。。。。。。。
default ：//如果前面的所有“相等判断”都不成立，则会执行本默认语句块
//本default语句部分也可以没有。
//默认语句块
}
特别案例：
*switch case非常量的逻辑判断用法true
(逻辑判断返回的结果是布尔值[也可以看做一个常量])
*特别提醒：
3.while 循环结构
【循环变量初始化exp1】 //所谓初始化，就是给一个变量赋一个初值
while ( 【循环变量条件判断exp2】 )
//条件判断如果成立（true ），则执行其中的语句块
{ //循环语句块
// 循环中的语句块执行完之后，会自动回到 while 语句的开始继续判
断．．．
【循环变量值的改变exp3】
}
4.do while 循环结构
【循环变量初始化exp1】 do {
//循环语句块——本大括号中所有语句作为整体常常也被称为“循环体” 【循环变量值的改变exp3】 }
while (【循环变量条件判断exp2)】;
do while 循环语句是先进入循环体执行一次循环语句，然在进行while 之后的那个循环条件判断。如果判断成立，则继续进行循环体语句的执行，否则循环结束。
do while 循环语句跟while 语句的最大区别是：do while 循环语句必定会执行一次语句块。
5.for 循环结构
for(【循环变量初始化exp1】 ； 【循环变量条件判断exp2) 】 ； 【循环变量值的改变exp3】 ) {
//【循环体——循环语句块 exp4】
}
for 循环语句的执行顺序： exp1 → exp2 → (true) → exp4 → exp3 → exp2 →(true) → exp4 →exp3 →exp2 →（true ） …..
→ (false) →for 结束
→ false → (结束)
→ false → (结
束)
案例：求1！+2！+3！+…….+n! var n=window.prompt("请输入一个数"); sum=0; temp=1;
for(var i=1;i<=n;i++){ for(var j=1;j<=i;j++){ temp=temp*j; }
sum=sum+temp; temp=1;
TRue
false
for 循环结束
document.writeln(sum);
在ie8中，我们可以通过工具来对JS代码进行调试，尤其页面比较复杂的情况下非常有用。
在ie8中，通过开发人员工具，就可以进行JS的调试工作。
案例：打印出半个金字塔，整个金字塔，空心金字塔，菱形，空心菱形的代码见金字塔.html文件var n = parseInt(window.prompt("输入一个值"));
/*for(var c=1;c<=n;c++)
{
for(var q=1;q<=n-c;q++)
{document.writeln(" ");}
//递减规律
//for(var y=1;y<=2;y++)
for(var y=1;y<=2*c-1;y++)//奇数个数
{document.writeln("*");}
document.write("
");
}*/
//空心金子塔
/*for(var c=1;c<=n;c++)
{
for(var j =1;j<=n-c;j++)
{document.writeln(" ");}
for(var q=1;q<=2*c-1;q++){
if(q==1 || q==2*c-1)
{document.writeln("*");}
else if(c==n)
{document.writeln("*");}
else
{document.writeln(" ");}
}
document.writeln("
");
}*/
//空心菱形
if(n%2 == 0){n++;}
for(var c=1;c<=n/2+1/2;c++)
{
for(var d=1;d<=(n/2+1/2)-c;d++)
{document.write(" ");}
for(var i=1;i<=c;i++)
{
if(i==1 || i==c)
{document.writeln("*");}
else
{document.writeln(" ");}
document.write("
");
}
for(var j=1;j<=n/2-1/2;j++)
{
for(var c1=1;c1<=j;c1++)
{document.write(" ");}
for(var a=(n/2)-(1/2);a>=j;a--)
{
if(a==(n/2)-(1/2) || a==j)
{document.writeln("*");}
else
{document.writeln(" ");}
}
document.write("
");
}
案例：水仙花数//水仙花数是指一个n位数，每一位数字的n次幂的和正好等于这个数本身var a,b,c;
for(var i=100;i<1000;i++)
{
a=parseInt(i/100);
b=parseInt((i%100)/10);
c=i%10;
if((Math.pow(a,3)+Math.pow(b,3)+Math.pow(c,3)) ==i)
{document.writeln(i);}
}
特别案例：
6.return两个关键字break和continue
break：在循环、switch里边有使用
跳出当前的本层循环
continue：在循环里边使用
跳出本次循环，进入下次循环
多个循环嵌套使用：
flag：//标志
for1
red:
for2
for3
break;(把for3直接跳出)
continue;(跳出本次的for3)
//break 3;//php语法
break flag; 或continue flag;//把标志对应的for(本层)循环给做跳出操作
break red; 或continue red;
四．函数
1.基本感念
函数的基本概念：为完成某一个功能的代码（语句，指令）集合
2.函数的定义形式：
1)第一种形式
function 函数名(【形式参数1】，【形式参数2】，【形式参数3】…….. )
{
//函数体（语句块）
【return某值；】//return语句可以没有。如果没有return，表示该函数没有返回值。}
*参数名前不要带var
该方式的函数有“预加载”过程，允许我们先调用函数、再声明函数
预加载：代码先把函数的声明放入内存。代码开起来是先调用、后声明，本质是先声明、后调用的。
2)变量赋值方式声明函数
var 函数名= function(){}
该方式没有“预加载”，必须先声明、后调用。
3.函数的调用形式：
1)传统调用方式：
函数名(【实际参数1】，【实际参数2】，【实际参数3】…….. )
a.函数进一步说明：
1，函数定义的时候，形式参数只能是一个“形式名”，即是一个虚的名字（变量），而不能是一个实际值2，函数调用的时候，实际参数只能是一个“实际值”，该值可以是一个“直接值”也可以是一个有值的变量。3，函数调用的时候，实际参数的值会按顺序依次传递到形式参数对应顺序上的那个变量中去。
4，函数调用的时候，传完所有参数之后，才开始执行函数体内的所有语句。
a)执行过程中，如果碰到return语句，则函数立即结束，并返回到调用的位置
b)如果没有碰到return语句，则函数中语句按正常的逻辑顺序执行完之后会返回到调用的位置。
函数的参数：
function 函数名(形参1,形参2，形参3=’abc’){}
函数名(‘tom’,23,’beijing’);//传递实参信息
没有默认值情况：
在php里边：实参的个数小于形参是不允许的
在javascript里边：实参与形参没有严格的对应关系
function f1(name,age,addr='beijing'){
console.log('个人信息：'+"名字:"+name+";年龄："+age+";地址："+addr);
}
f1('linken','45','usa');
f1('tom','20');
f1('mary');
f1();
*注：函数的参数可以有0个或多个，根据实际函数的功能需要我们自己来设定。
b.函数的返回值：
函数可以有返回值，也可以没有返回值。一个函数有没有（需不需要）返回值，没有特定规律，也是要根据实际函数个功能需求来决定。
有返回值举例：已知半径算圆面积，已知两个直角边，算对应斜边，已知月薪，算个人所得税。
有返回值一定要使用return 后面加一个“值”。
无返回值举例：给出一个初始n值，输出n层倒金字塔。
一个函数如果有返回值，则通常调用函数的时候需要“充分利用”该值：给别人赋值或直接输出。
var v1 = 函数名((实际参数列表) + 5；
document.write( 函数名((实际参数列表) );
alert (函数名((实际参数列表) )
一个函数如果没有返回值，则不可以参与运算或输出，通常其调用就只能是这样：
函数名(实际参数列表)；
*关于接收函数返回值得讨论
function test(val){
window.alert("你得输入是"+val);
return 90;
}
var myvar=test("abc"); //输出abc
window.alert(myvar); //输出90，如果函数没有返回值（函数test里没有写return xxxx ;）则返回undefined，如果有返回值，则返回什么就是什么（90）
c.return 和 break的区别：
return用于函数中，结束函数。除此之外，return还可以返回数据（值）
案例:
function a(){
this.a = 1;
this.b = 3;
return1;
this.c = "zhanghao";
}
alert(new a().c);//undefined
break用于循环中，结束循环。break没有返回数据的能力。但break也可以用switch。
*特别提醒：
*注：var time=setInterval("showTime()",1000);
函数setInterval()调用时,将它返回的值赋给一个变量time];
入门案例：