这篇博客是全面的JavaScript教程，涵盖了从基础到高级的所有内容，包括JavaScript的起源、ECMAScript标准、作用域规则、数据类型转换、流程控制、函数基础和内置对象的使用。此外，还介绍了如何学习JavaScript，推荐了开发工具和调试方法。
教程：JS学习
保姆级教程，你甚至可以拿去当教案，因为我也是复制粘贴加自己总结
1.介绍JavaScript
js
JavaScript一种轻量级的脚本语言，也是一种嵌入式（embedded）语言，是一种 对象模型 语言，简称 JS。
JavaScript被认为是客户端“脚本”，它不常叫“语言”，言外之意是比较简单，但是深入了解之后，你会发现，简单的外表下，蕴藏着丰富的内涵。
历史(喜欢就看看)
1994年Netscape（网景）公司推出免费版本浏览器 Netscape Navigator(网景浏览器1.0)
1995年微软公司发布 Internet Explorer 1.0。
1995年网景公司为适应市场变化，需要开发一门专门在浏览器运行的脚本语言，这个任务交给了布兰登，为了应付公司安排的任务，
他只用10天时间就提交了工作，并将这门语言命名为 LiveScript;
后来为了蹭sun公司java的热度,与sun公司合作，将其临时改名为“JavaScript”;
1996年8月，微软模仿JavaScript开发了一种相近的语言，取名为JScript，首先内置于IE 3.0。
1997年7月，ECMA组织（欧洲计算机制造商协会）发布ECMAScript 1.0版；
此后，明争暗斗不断，1998年6月，ECMAScript 2.0版发布，1999年12月，ECMAScript 3.0版发布；
2007年10月，ECMAScript 4.0版草案发布，2008年7月中止ECMAScript 4.0的开发，并发布3.1版本；
会后不久，ECMAScript 3.1就改名为ECMAScript 5。
2011年6月，ECMAscript 5.1版发布，现在使用最为广泛的版本 版发布，现在使用最为广泛的版本；
2015年6月，ECMAScript 6正式发布，并且更名为“ECMAScript 2015”；
随后，ECMA组织决定，每年发布一个升级版本，以年号来代替版本号，如：ECMAScript 2016、ECMAScript 2017；
总结：es6 = ECMAScript 2015，这里的ES5并不特指ECMAScript 5， 而是代表ECMAScript 6 之前的ECMAScript！
课外知识：
1996年，样式表标准CSS第一版发布；
1997年，DOM模式第一版正式应用，目前的通用版本是DOM3，下一代版本DOM 4正在拟定中。
1999年，IE5部署了XMLHttpRequest接口，允许JavaScript发出HTTP请求；
2001年，提出了JSON格式，用于取代XML格式。
2002年，Mozilla项目发布第一版Firefox。
2003年，苹果公司发布了Safari浏览器的第一版。
2006年，jQuery函数库诞生
2007年，Webkit引擎在iPhone手机中得到部署；
2008年，为Chrome浏览器而开发的V8编译器(解析引擎)诞生；
2009年，基于V8解析引擎的Node.js项目诞生,迎来前后端JS的霸权时代；
2009年，Google发布Chrome OS
2009年，Google发布Angular框架；
2013年，Mozilla基金会发布手机操作系统Firefox OS，该操作系统的整个用户界面都使用JavaScript；
2013年5月，Facebook发布UI框架库React；
2014年，尤雨溪发布开源前端开发库Vue.js；
2015年3月，Facebook公司发布了 React Native项目；
ECMAScript和JavaScript
ECMA是一个组织，是欧洲计算机协会。是它制定了JavaScript的标准
ECMAScript简称ES，比如ES5就表示ECMAScript5版本，ES6就表示ECMAScript6版本。JavaScript简称JS，JS的版本随ECMAScript的版本变化而变化。
ECMAScript只是JavaScript的核心，我们现在学习的JavaScript包括JS的核心ECMAScript，并且还包含DOM和BOM。
总结：JavaScript = ECMAScript+DOM+BOM
JS的强大用作用
数据验证（表单验证）
网页特效（目前大多数的网页特效都是通过JS编写）
编写网页小游戏
服务器端编程，数据交互（Ajax、Node.js）
2.如何学习JS
开发工具
“工欲善其事，必先利其器”
| 名称 | 描述 | 厂家 |
|---|---|---|
| vscode | 开源的 | 微软产品 |
| phpstrom、webstrom | 收费的 | JetBrains 公司 |
总结：vscode白嫖天下第一
调试浏览器
就用下面几个就行了，别的浏览器不推荐。
| 名称 | 内核 |
|---|---|
| Edge | webkit |
| chrome | webkit |
| firefox | Gecko |
| sarfi | webkit |
总结：最新的edge微软的天下第一，开发者工具支持中文，爽
3.语言基础
代码位置
代码位置一
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<script>
console.log("可以放在");
</script>
</head>
<body>
</body>
</html>
代码位置二
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<script src="./demo.js"></script>
</head>
<body>
</body>
</html>
console.log("不用写script标签了，直接开撸代码")
输出
document.write(输出的内容); //这种输出的内容会显示在浏览器页面上
alert(输出的内容); //这种方法输出的内容会以提示框的形式显示
console.log(输出的内容); //输出的内容会显示在浏览器的控制台
语句和表达式
JavaScript程序的执行单位为行（line），也就是一行一行地执行。一般情况下，每一行就是一个语句。
语句（statement）是为了完成某种任务而进行的操作，比如下面就是一行赋值语句
var a = 1 + 3
这条语句先用var命令，声明了变量a，然后将1 + 3的运算结果赋值给变量a
1 + 3叫做表达式（expression），指一个为了得到返回值的计算式
语句和表达式的区别在于，前者主要为了进行某种操作，一般情况下不需要返回值；后者则是为了得到返回值，一定会返回一个值
凡是JavaScript语言中预期为值的地方，都可以使用表达式。比如，赋值语句的等号右边，预期是一个值，因此可以放置各种表达式。一条语句可以包含多个表达式。
语句以分号结尾，一个分号就表示一个语句结束。多个语句可以写在一行内。
var a = 1 + 3 ; var b = ‘abc’;
分号前面可以没有任何内容，JavaScript引擎将其视为空语句。
;;;
上面的代码就表示3个空语句
<script>
console.log("A")
console.log(1+1)
</script>
JS语言中，一条语句结束，可以不用写分号，直接用回车即可。但是建议大家每条语句后面都加分号
注释
单行注释：//这是一行注释
多行注释：/这是一段注释/
4.变量
什么是变量
变量是计算机内存中存储数据的标识符，根据变量名称可以获取到内存中存储的数据
为什么要使用变量
使用变量可以方便的获取或者修改内存中的数据
如何使用变量
var a = 1; //声明变量，赋初值为1
var b; //声明变量，但是没有给初始值
b = 2;//给变量赋值
var c = 3, d=4, e,f=5;//一次性声明多个变量 注意：这里是用逗号
//使用，直接不用携带var 用就行了
console.log(a,b,c,d,e,f); //1 2 3 4 undefined 5
变量命名规则
规则
由字母、数字、下划线、$符号组成，且不能以数字开头
不能是关键字和保留字，例如：for、while、this、name
区分大小写
规范
遵守驼峰命名法。(首字母小写，后面单词的首字母需要大写。例如：userName、userPassword）
声明变量没有赋值
var a;
console.log(a);
结果是
总结：没有赋值默认时undefined
重新声明变量
var x = 10;
var x;
console.log(x);
结果
总结：只声明没有赋值，不会改变原来的结果，这一点和php是一样的。
变量提升(hoisting)
console.log(a);
var a = 10; //undefined
这段代码执行的时候会变成这样
var a;
console.log(a); //会把变量的声明提升到使用变量之前，所以结果是undefined
a = 10;
变量的删除
var a = 10;
b = 20;
console.log(a,b);
//无法删除通过var声明的变量
//delete a;
//成功删除 b;
delete b;
console.log(a,b);//b is not defined
5.常量
定义常量
JS中定义常量，只有const语法
//定义常量
const A = 123;
console.log(A); // 123
const a = 100;
a = 200;
console.log(a);
总结：常量定义了，就不能赋值改变。
常量的作用域
for(i=0;i<3;i++){
const a = 4;
console.log(a);
}
console.log(a);
总结：常量的作用域，是常量所在的块。（块可以理解为大括号）
6.运算符
赋值运算符(Assignment operators)
赋值运算符是一个 “=”。表示将“=”后面的内容赋值给左边的内容。
比较运算符(Comparison operators)
案例一：
var a =1;
if(a>0){
alert("是");
}else{
alert("否");
}
案例二：
var a =1, b = "b";
if(a=b){
console.log("true")
}else{
console.log("false")
}
案例解析：
先把b赋值给a，实际上是判断赋值后的结果 字符串"b"，字符串转换为boolean类型则是true
算数运算符(Arithmetic operators)
加减乘除取余
取余操作演示
var a = 3, b = 4;
console.log(a % b);//3
案例：不用第三个变量交换变量的值
var a=10,b=20;
解：
var a=10,b=20;
a = a+b;//a = 30
b = a-b;//b = 30-20 = 10 注意：此时的b已经从20变成10
a = a-b; // a = 30 -10
console.log("a="+a,"b="+b);
总结：看似简单，刚开始可能还没思路。
逻辑运算符(Logical operators)
这个很重要，不要小看，且高级写法，很多都有这个东西。
var a = 1,b=2,c=0,d=false;
var x1 = a || b;
var y1 = c || b;
console.log(x1); //1
console.log(y1); //2
// ||总结：如果左边为true 则等于左边，左边为false，则等于右边
var x2 = a && b;
var y2 = c && b;
console.log(x2); //2
console.log(y2); //0
// &&总结：如果左边为true 则等于右边，左边为false，则等于左边
别看这个是小知识点，很多封装的插件中就有这个写法的使用，基础不好很难阅读。
// &&的高级示例
// 如果这个函数存在就调用
if (f1) {
f1();
}
// 简写
f1 && f1();
//||的高级示例
//兼容浏览器的写法
var e = window.event || evt;
字符串运算符(String operators)
php中用.来拼接字符串
js中使用+号来连接字符串
console.log(2+2);
console.log(2+"js");
console.log("hello"+"js");
条件（三元）运算符(Conditional operator)
元，表示参与运算的参数个数。三元意思就是参与运算的有三个值。
var a = (b>c) ? x : y;
一元运算符(Unary operators)
var a = 2, b = 3;
var c = a++; // var c = a; a = a+1
var d = ++b; // b = b+1; var d=b;
console.log(a, b , c, d); // a=3, b=4, c=2, d=4
总结：++在后是先赋值后运算，++/–在前是先运算后赋值。
其它
void
void 它是一个函数或是一个语言结构，返回值总是无效的undefined。经常用它来使得超链接变得无效。
语法：
void(0);
void 111;
console.log(void(0));
console.log(void 111);
案例：让超级连接无法跳转，就这一个用处
<a href="javascript:void(0)">aaaa</a>
typeof
它是一个函数或是一个语言结构。typeof(a)、 typeof a; 用于判断变量的数据类型。
语法：
typeof(a)
typeof a;
in
用于判断下标是否存在数组中，或判断对象中是否有哪个成员
instanceof
判断对象的原型
7.数组
声明数组
注意：在JS中，数组也是一种特殊的对象。
三种声明方式：
var arr = []; //空数组
var arr = [‘js’, ‘php’];
var arr = new Array(); //空数组
var arr = new Array(‘js’, ‘php’);
var arr = new Array(4); //表示数组中有四个单元
我相信上面几个都问题，我们看看最后一个就行了
var arr = new Array(4);
console.log(arr)
获取数组的元素
使用“数组[下标]”可以获取到数组中的值。
JS中数组的下标一定是数字类型的。
var arr = new Array(4);
arr = ["js", "php"];
console.log(arr);
//获取数组的长度
console.log(arr.length);//2
//获取元素
console.log(arr[0]); //js
判断下标是否存在
使用 in 来判断下标是否存在。
语法： 下标 in 数组 如果存在返回true，不存在返回false。
var arr = new Array(4);
arr = ["js", "php"];
console.log(0 in arr); //true
console.log(1 in arr); //true
console.log(2 in arr); //false
清空数组
var arr = new Array(4);
arr = ["js", "php"];
//方法一
arr = [];
console.log(arr);//[]
//方法二
var arr2 = ["js", "php"];
arr2.length = 0;
console.log(arr2);//[]
8.对象
创建对象
JS中要得到一个对象有很多种方式，后面面向对象会详细说。
得到对象最简单的一个方式：直接量语法
语法：
var obj = {}; //空对象
var obj = {成员名:值, 成员名:值};
var obj = {
成员名:值,
成员名:值
};
var obj1 = {}
var obj2 = {
name:"Jack",
age:20
}
var obj3 = {
name:"Jack",
age:20,
hody:['吃','喝','玩','乐'],
show:function(){
console.log("我叫Jack");
}
}
console.log(obj1);
console.log(obj2);
console.log(obj3);
注意：值可以是数字型、字符串型等基本数据类型，也可以是数组或其他对象，还可以是函数。
获取对象成员,同时理解this
注意：对象内部的this等于php中的$this
var obj1 = {}
var obj2 = {
name:"Jack",
age:20
}
var obj3 = {
name:"Jack",
age:20,
hody:['吃','喝','玩','乐'],
show:function(){
console.log("我叫"+this.name);
}
}
// console.log(obj1);
// console.log(obj2);
// console.log(obj3);
console.log(obj3.name);
console.log(obj3.age);
console.log(obj3.hody);
//调用对象方法
obj3.show();
判断对象的成员
用 in 判断对象中是否存在某个成员
var obj3 = {
name:"Jack",
age:20,
hody:['吃','喝','玩','乐'],
show:function(){
console.log("我叫"+this.name);
}
}
console.log('name' in obj3);
console.log('abc' in obj3);
console.log('show' in obj3);
添加对象的成员
var obj3 = {
name:"Jack",
age:20,
hody:['吃','喝','玩','乐'],
show:function(){
console.log("我叫"+this.name);
}
}
//给对象添加一个新的成员
obj3.gender = "先生";
//给对象添加一个新的成员是一个函数
obj3.say = function(){
console.log(this.gender);
}
//查看新的成员属性和方法
console.log(obj3.gender);//先生
obj3.say(); //先生
删除对象的成员
使用delete关键字来删除对象的成员
var obj3 = {
name:"Jack",
age:20,
hody:['吃','喝','玩','乐'],
show:function(){
console.log("我叫"+this.name);
}
}
console.log(obj3);
//删除成员属性
delete obj3.name;
//删除成员中的方法
delete obj3.show;
console.log(obj3);
9.数据类型
数据类型概念
JavaScript 语言的每一个值，都属于某一种数据类型。
JavaScript 的数据类型，共有六种。（ES6 又新增了第七种 Symbol 类型的值）
1.number ：分为 int float
2.string：
3.bool：
4.null ： 空值，如果要设置一个变量的值为null，只能手动赋值为null。null也是一个对象。
5.undefined ：未定义，如果一个变量声明了，但是没有给值，则这个变量的值就是undefined
6.object: 分为下面这几种
纯对象（狭义上的对象）
数组
函数
JS中任何数据类型都可以看做是对象
1.通常，我们将数值、字符串、布尔值称为原始类型（primitive type）的值，即它们是最基本的数据类型，不能再细分了。
2.而将对象称为合成类型（complex type）的值或引用类型，因为一个对象往往是多个原始类型的值的合成，可以看作是一个存放各种值的容器。
3.undefined和null，一般将它们看成两个特殊值。
数据类型示例
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = {name:"li",age:20};
var h = [1,2,3];
function fun(){
};
console.log("a=>"+typeof a);
console.log("b=>"+typeof b);
console.log("c=>"+typeof c);
console.log("d=>"+typeof d);
console.log("e=>"+typeof e);
console.log("f=>"+typeof f);
console.log("g=>"+typeof g);
console.log("h=>"+typeof h);
console.log("fun=>"+typeof fun);
彻底区分数据类型
我们发现
使用typeof无法区分null、数组、对象，要想区分他们三个，必须使用instanceof
变量 instanceof 类型
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = {name:"li",age:20};
var h = [1,2,3];
function fun(){
};
console.log(e instanceof Array);//false
console.log(h instanceof Array);//true
封装一个判断数据类型的函数
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = { name: "li", age: 20 };
var h = [1, 2, 3];
function fun() {
};
//判断数据类型
function myTypeOf(x) {
if (typeof x != "object") {
return typeof x;
} else {
if (x instanceof Array) {
return 'Array';
} else if (x instanceof Object) {
return 'Object';
} else {
return 'null';
}
}
}
console.log(myTypeOf(e));
console.log(myTypeOf(g));
console.log(myTypeOf(h));
原始类型和引用类型(结合内存图理解)
引用类型指对象，指的是狭义上的对象。数组不应该算引用类型
10.数据类型的转换
转换成字符串
变量.toString()，null和undefined不支持，会报错
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = { name: "li", age: 20 };
var h = [1, 2, 3];
function fun() {
console.log("我是fun方法");
};
console.log(a.toString());
console.log(b.toString());
console.log(c.toString());
console.log(d.toString());
// console.log(e.toString()); 报错
// console.log(f.toString()); 报错
console.log(g.toString());
console.log(h.toString());
console.log(fun.toString());
String(待转换的变量)，null和undefined支持
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = { name: "li", age: 20 };
var h = [1, 2, 3];
function fun() {
console.log("我是fun方法");
};
console.log(String(e));
console.log(String(f));
隐式转换：在其他数据类型和字符串类型进行连接操作时，会使用String()转换后再和字符串拼接
var a = 1;
var b = 1.1;
var c = "js";
var d = true;
var e = null;
var f;
var g = { name: "li", age: 20 };
var h = [1, 2, 3];
function fun() {
console.log("我是fun方法");
};
console.log(e+"js");
console.log(f+"js");
转换成数值
parseInt() – 转换成整型
简单说明：
方法首先查看位置 0 处的字符，判断它是否是个有效数字；
如果不是，该方法将返回 NaN(not a number)，不再继续执行其他操作。
但如果该字符是有效数字，会一直查找到不是有效数字就停止查找
console.log(parseInt("a123.3"));//NaN
console.log(parseInt("a123"));//NaN
console.log(parseInt("123"));//123
console.log(parseInt("123abc"));//123
console.log(parseInt("123abc456"));//123
console.log(parseInt("123abc456"));//123
console.log(parseInt("123.51"));//123不会四舍五入 它是从左到右看是否是有效数字，那个点不是数字不找了
console.log(parseInt("123.15"));//123
parseFloat() – 转换成浮点型
道理和转换成整型道理一样，只不过浮点型允许有一个小数点出现。
console.log(parseFloat("a123.3"));
console.log(parseFloat("123.3"));
console.log(parseFloat("123.33"));
console.log(parseFloat("123.333.44"));
Number() – 强制转换
它是先判断值是否能被完整地转换成数字，不能返回NaN，能则内部进行判断调用parseInt() 还是 parseFloat()；
转换成boolean
显示的转换是使用Boolean()函数，对需要转换的内容进行转换。
以下内容在转换成布尔值时会被转换成false
数值型的 0
数值型的 0.0
布尔型的 false
空字符串 “”
非数字 NaN
undefined
null
除此以外，其他所有值都会转换成true，包括 “0”、空数组 [] 和空对象 {}
11.流程控制
顺序结构
顺序结构，体现了代码从上到下依次执行。
如何打破它？
变量提升。
console.log(a); // undefined 这种情况不会报错
var a = 1;
// 实际上等于这个
var a;
console.log(a); // undefined 这种情况不会报错
a = 1;
函数预加载。
a();
function a(){
console.log("我还是可以正常执行");
}
函数预加载的条件：
1.函数声明的方式必须是常规方式，什么是常规方式？
a();
//常规方式
function a(){
console.log("a");
}
b();
//函数表达式形式
var b = function b(){
console.log("b");
}
2.函数的声明和调用在同一个script段中
分支结构
if()…else….
if()…else if()…else…
switch (待比较的变量) {
case xxx:
xxx;
break;
}
var week = new Date().getDay(); //获取一个数字格式的星期
//console.log(week);
var week_zh_cn; //中文格式的星期
switch (week) {
case 2:
week_zh_cn = '二';
break;
case 3:
week_zh_cn = '三';
break;
case 1:
week_zh_cn = '一';
break;
case 4:
week_zh_cn = '四';
break;
case 5:
week_zh_cn = '五';
break;
case 6:
case 7:
week_zh_cn = '末';
break;
default:
console.log('格式错误');
break;
}
console.log('今天是星期' + week_zh_cn);
循环结构
while…
var i = 0;
while(i<10){
console.log(i);
i++;
}
do…while…
var a = 0;
do {
console.log(a);
a++;
} while (a < 10);
总结：这个是至少先做一次，然后再根据条件决定是否继续
for…
var arr = ['php', 'js', 'html', 'css', 'jq'];
for (var b in arr) {
//b 表示数组的下标
//arr[b] 表示数组中的每个值
console.log(b, arr[b]);
}
var obj = { name: 'Jack', age: 21, hoby: 'Writecode' };
for (var i in obj) {
// i 表示对象的成员名
// obj[i] 表示对象的属性值，对象的属性名如果是变量，则必须使用下标的形式查找对象的属性值
console.log(i, obj[i]);
}
总结：专门用于遍历数组和对象的
continue和break
循环可以嵌套
//循环可以嵌套
for (var i = 1; i <= 3; i++) {
for (var j = 1; j <= 3; j++) {
console.log(j + '-' + i);
}
}
continue:跳过当此循环
for (var i = 1; i <= 3; i++) {
for (var j = 1; j <= 3; j++) {
if(j == 2){
continue;
}
console.log(j + '-' + i);
}
}
我们发现第一排带2的都没了。
break：用来终止循环，让循环不再往下继续
for (var i = 1; i <= 3; i++) {
for (var j = 1; j <= 3; j++) {
if(j == 2){
break;
}
console.log(j + '-' + i);
}
}
我们发现，左侧大于等于2的都没了
给循环起名字，配合break使用
我们在php中的话，可以通过break 层级数字；来跳出循环。
break 数字；
js中则不行，语法都会报错。
a:for (var i = 1; i <= 3; i++) {
b:for (var j = 1; j <= 3; j++) {
if(j == 2){
//break 2;//语法报错
break a;
}
console.log(j + '-' + i);
}
}
我们发现，里面的循环执行完一次后，直接跳出a循环了
12.函数基础
定义和调用
// 定义一个求 指定数n 从1+2+3+ ...+n的函数
function mySum(num) {
//定义一个变量用来存总合
var s = 0;
//注意：包括N ,所以要小于等于n
for (var i = 1; i <= num; i++) {
s += i;
}
return s;
}
//调用函数
var sum = mySum(100);
console.log(sum);
函数表达式形式
把常规方式定义的函数，当作一个值，赋值给另外一个变量，通过变量名调用函数
// 定义一个求 指定数n 从1+2+3+ ...+n的函数
function mySum(num) {
//定义一个变量用来存总合
var s = 0;
//注意：包括N ,所以要小于等于n
for (var i = 1; i <= num; i++) {
s += i;
}
return s;
}
//调用函数
var sum = mySum(100);
console.log(sum);
//用一个变量来接收
var b = mySum;
console.log(b(10));
既然函数可以作为一个变量，那么就可以像定义变量一样来定义函数，这就是函数表达式的形式
定义语法：
var b = function (x){
console.log(x);
};
b(1); //调用函数
函数预加载
a();
function a(){
console.log("a");
}
b();
var b = function b(){
console.log("b");
}
报错的原因：因为b方法是通过函数表达式定义的。函数预加载是必须要通过常规方式定义，且必须在同一个script标签。
立即调用模式
//立即调用,前面可以加 *!+- 否则语法报错。 不推荐
-function (a, b) {
console.log(a+b);
}(1,2);
//推荐
(function (a, b) {
console.log(a+b);
})(1,2);
参数
形参：定义函数时，约定的参数
实参：调用函数时，传递给函数的实际值。
JS函数，参数传递非常灵活，定义的形参和实际传入的实参个数可以不一样。
怎么证明？看代码
function a(x,y){
console.log(x+y); //3
}
//你多传递几个实参也不会报错啊
a(1,2,3,4);
注意：ES5中，函数的参数不可以用默认值。ES6中，函数的参数可以有默认值的。目前IE11只支持部分ES6的内容。
那么在ES5中，如何实现形参有默认值的写法呢？
function a(x, y) {
//判断到底传递没传递
if (y == undefined) {
y = 3;
}
console.log(x + y);
}
a(1);
a(1, 2);
高级写法
function a(x, y) {
//判断到底传递没传递
// if (y == undefined) {
// y = 3;
// }
//高级写法
y = y || 3;
console.log(x + y);
}
a(1);
a(1, 2);
13.作用域
作用域分类
作用域指的是变量起作用的范围。
分为全局作用域和局部作用域。其中局部作用域也叫做函数作用域。
作用域的规则
规则一：函数可以使用函数以外的变量
var a= 10;
function b(){
console.log(a);
}
b();
规则二：函数内部，优先使用函数内部的变量
var a= 10;
function b(){
var a= 20;
console.log(a);
}
b();
函数内部也会发生变量提升：
function b(){
console.log(a);
var a= 20;
}
b();
规则三：函数内部没有用var声明的变量，也是全局变量
var a =10;
function b(){
//更改全局变量的值
a = 30;
console.log(a);
}
b();
作用域链
在内部函数中查找变量的时候，优先从函数内部自身查找，如果没有查到，则向外层查找，如果外层还没有，则继续向上一层查找，一直查询到全局作用域。这种链式的查找方式就是作用域链。
var a = 10;
function fn1(){
var a = 20;
function fn2(){
var a = 30;
console.log(a);
}
fn2();
}
fn1();
会输出什么呢？
14.标准库(内置对象)
以下是参考文档，下面列出几个常用对象的常用方法
参考资料
https://developer.mozilla.org/zhCN/docs/Web/JavaScript/Reference/Global_Objects
http://www.w3school.com.cn/jsref/index.asp
Math对象–数学对象
学习到这个，我有点想哭，慢慢的回忆啊
属性：
//圆周率
Math.PI
方法：
//绝对值
Math.abs();
//上取整
Math.ceil()
// 下取整
Math.floor()
//下取整和上取整演示
Math.ceil(8.8) == 9；Math.ceil(-8.8) == 8；
Math.floor(8.8) == 8；Math.floor(-8.8) == -9；
//对数进行四舍五入
Math.round()
//返回（0,1]的随机数
Math.random()
随机整数公式：
//j 表示最大值，i表示最小值
Math.floor(i + Math.random() * (j – i + 1));
Date对象–时间日期对象
获取 年、月、日、时、分、秒、（星期）
var d = new Date(); //实例化，得到对象
//获取年
var nian = d.getFullYear();
//实例化Date对象
var d = new Date();
//获取四位数的年
var nian = d.getFullYear();
//获取月（0~11）
var yue = d.getMonth() + 1; //加 1 之后，才是正常的月
//获取日
var ri = d.getDate();
//获取时
var shi = d.getHours();
//获取分
var fen = d.getMinutes();
//获取秒
var miao = d.getSeconds();
console.log(nian + '年'+yue+'月'+ri+'日 '+shi+':'+fen+':'+miao);
//输出结果：2018年9月1日 17:12:11
//获取时间戳
var times = d.getTime();
String对象–字符串对象
String对象中提供的方法都是处理字符串
用法一
var s = new String(要处理的字符串); //实例化对象
console.log(s.substr(1)); //对象通过点语法调用String对象的成员方法
实例代码
var s = new String('hello world');
console.log(s.length); //表示字符串长度
console.log(s.indexOf('a')); // 没有查到，返回-1
console.log(s.indexOf('l')); //查到了，返回位置 2
用法二
console.log(要处理的字符串.substr(1));
实例代码
console.log('hello world'.indexOf('e')); // 1
console.log('abcdefg'.substr(2, 3)); // cde
Array对象–数组对象
语法：
//首先创建一个数组
var arr = ['apple', 'pear'];
var arr = new Array('apple', 'pear');
//因为数组也是对象，那么就可以直接使用 数组.成员方法
arr.push('xigua');
console.log(arr); // ['apple', 'pear','xigua']
//首先先得到一个数组
var arr = ['apple', 'pear'];
//调用push方法，向数组中添加单元
var length = arr.push('xigua'); //添加完返回新的长度 3 array_push()
console.log(length, arr); //已经是新的数组了，里面有三个水果
扫一扫
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
