js
目录
1.Javascript简介
2.Javascript基础
3.运算符
4.分支语句
5.循环语句
6.数组
7.对象和函数
1.Javascript简介
JavaScript是一种轻量级的脚本语言，可以部署在多种环境，最常见的部署环境就是浏
览器。所谓“脚本语言”，指的是它不具备开发操作系统的能力，而是只用来编写控制其
他大型应用程序的操作方法。
JavaScript的核心部分相当精简，只包括两个部分：
1.基本的语法构造（比如操作符、控制结构、语句）
2.标准库（就是一系列具有各种功能的对象比如Array、Date、Math等）。
除此之外，还有提供的额外API可以分成三大类：浏览器控制类、DOM类、Web类。
2.Javascript基础
字符串的字面量，必须用双引号、单引号包裹起来。字符串被限定在同种引号之间；也即，必须是成对单引号或成对双引号。
<script>
console.log("今天天气很好");
console.log("哈哈");
console.log("3")
var res = prompt("请输入一个数："); //输入一个数
var ans = prompt("请输入一个数",100); //参数1：输入内容
var isint = parseInt("123"); //将字符串转换成整型
var isfloat = parseFloat("3.14") //将字符串转换成浮点型
</script>
变量：
其表示的值可以发生改变的量，叫做变量。
var a; //a表示一个变量，a是变量的变量名。
/*
1.创建一个变量的过程叫做变量的声明。
2.给变量一个具体的值的过程叫做变量的赋值。(变量在赋值之前必须被声明)a = 10;
3.将变量的声明和赋值写在一起的方式叫做变量的初始化。var a = 10;
*/
Javascript变量命名规则
1.JavaScript语言的标识符对大小写敏感，所以a和A是两个不同的标识符。
2.首字母可以是任意字母以及美元符号和下划线。剩余可以是任意字母，美元符号，下
划线和数字
aNum FrankenStein _My_Id $name4 $user_address
ps:不能使用数字来当做命名的首位。
3.不能使用javascript中的关键字(保留字)来命名变量
eg： arguments、break、case、catch、class、const、continue ……
4.常用命名方式：驼峰命名法(首字母大写，其余字母小写)
eg： var userName = 15;
ps:给变量命名一定要给有意义的名字，不要使用类似a、b、c之类的无意义名字。
Javascript变量类型
/*Javascript中有六大数据类型，这六种数据类型也就是我们声明变量的类型。
1.number 数字类型
2.string 字符(串)类型
3.boolean 布尔类型
4.null 空类型
5.undefined 未定义类型
6.object 对象类型
*/
/*ps：JavaScript 拥有动态类型
JavaScript 拥有动态类型。这意味着变量可以根据其保存的值的类型不同，显示为不同的类型。*/
var x // x 为 undefined类型
var x = 6; // x 为数字类型
var x = “Bill"; // x 为字符串类型
number 数字类型
/*JavaScript 只有一种数字类型。数字可以带小数点，也可以不带：*/
var x1=34.00; //使用小数点来写
var x2=34; //不使用小数点来写
/*极大或极小的数字可以通过科学（指数）计数法来书写：*/
var y=123e5; // 12300000
var z=123e-5; // 0.00123
/*
JS中所有的数字都是number类型的，不在细分为整形int、浮点型float这些乱七八糟的
东西。number类型的东西：所有数字（不分正负、不分整浮、不分大小、不分进制）、
Infinity、NaN。
*/
string字符(串)类型
/*字符串是存储字符（比如 “Frankenstein"）的变量。字符串可以是引号中的任意文本。可以使用单引号或双引号：*/
var userName =“Frankenstein";
var userName =‘Ma Yun';
/*可以在字符串中使用引号，只要不与包围字符串的引号冲突即可：*/
var answer = "Nice to meet you!";
var answer = “He is called 'Frank'”;//外层是双引号，内层是单引号
var answer = 'He is called "Frank"';
boolean布尔类型
/*布尔（逻辑）只能有两个值：true 或 false。*/
var x=true；
var y=false；
/*布尔常用在条件测试中，表示真假值。*/
null 空类型
/*null类型表示数据类型存在，但是并没有给变量(对象)赋值。一般null类型用于对象类型的初始化。如果变量(对象)的值为null，并不代表变量(对象)没有类型*/
var name;
name = null；
console.log(name); //此时name就不再是变量，而是一个对象。类型就是null类型。
undefined 未定义类型
/*Undefined类型表示数据类型未知或者存在类型错误。如果变量的值为undefined，并
不代表变量没有类型！*/
var name;
console.log(name); //此时变量name的类型就是undefined类型
总结：undefined类型和null类型在页面中表现的效果是相同的，但是undefined用于
变量类型，而null用于对象类型。两者必须不能混用！！！！
object对象类型
/*对象由花括号分隔。在括号内部，对象的属性以名称和值对的形式 (name : value) 来定义。属性由逗号分隔：*/
var person={firstname:"Bill", lastname:"Gates", id:5566};
/*上面例子中的对象person有三个属性：firstname、lastname 以及 id。
ps:空格和折行无关紧要。声明可横跨多行：*/
var person={
firstname : "Bill",
lastname : "Gates",
id : 5566
};
/*对象属性有两种寻址方式（获取对象属性所对应的值的方式）：*/
name=person.lastname;
name=person["lastname"];
Javascript运算符简介
/*1.typeof 获取当前变量类型运算符（特殊）
2.= 赋值运算符
3.== 简要比较运算符（忽略变量类型）
4.=== 标准比较运算符（计算变量类型）
*/
//(1) typeof 获取当前变量类型运算符
var num=1;
console.log(typeof num);
var str = "1";
console.log(typeof str);
var obj={};
console.log(typeof obj);
var bool = false;
console.log(typeof bool);
bool = null;
console.log(typeof bool);//返回为object
console.log(bool);//null 已被清空false，变为null
var x;
console.log(typeof x);
/*(2)= 赋值运算符
赋值运算符用来给变量赋值。*/
var age = 14;
//ps：千万不要认为【赋值运算符】是【数学中的等号】。两者表达的是不同的内容。
//(3)== 简要比较运算符（忽略变量类型）
var age = 14;
console.log(age==12);//false
/*比较运算符的计算结果是一个布尔值。两个变量的比较结果要么是true，要么是false。
至于说忽略变量类型的原因，请看下面的例子：*/
var number1 = 10;
var string1 = “10”;
console.log(number1==string1);//true
(4)=== 标准比较运算符（计算变量类型）
var age = 14;
console.log(age===14);//true
var number1 = 10;
var string1 = “10”;
console.log(number1===string1);//false
/*标准比较运算符在比较两个变量的值的时候，既考虑变量的类型是否相等，又考虑变量的值是否相等。但是本质上说标准比较运算符也是比较运算符的一种，只不过比较的标准较严格一些。*/
3.运算符
js中有很多种类的运算符，不同的运算符拥有不同的作用。
- 算数运算符
- 赋值运算符
- 比较运算符
- 布尔运算符
- 三目运算符
算数运算符：
/*加法运算符：x+y
减法运算符：x - y
乘法运算符：x * y
除法运算符：x / y
余数运算符：x % y
自增运算符：++x 或者 x++
自减运算符：--x 或者 x--
*/
/*1.加法运算符
加法运算符（+）需要注意的地方是，它除了用于数值的相加，还能用于字符串的连
接。*/
'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"
(1 - '1' ) // 0
/*单目运算符（自增自减运算符）
单目运算符只需要一个运算子即可计算，表示对自身进行增加或者减少。使用时需要注意：
a.单目运算符放在运算子之前，先改变运算子本身，在参与计算结果。*/
var i = 1;
console.log(++i);//2
/*b.单目运算符放在运算子之后，先计算运算结果，语句执行完毕后在改变运算子本身。*/
var i = 1;
console.log(i++);//1
/*2.赋值运算符：
x+=y //相当于x= x+y
x-=y //相当于x= x-y
x*=y //相当于x= x*y
x/=y //相当于x= x/y
x%=y //相当于x= x%y*/
/*3.比较运算符：
比较运算符比较两个值，然后返回一个布尔值，表示是否满足比较条件。javascript提供了8个比较运算符：
x==y //判断是否相等（忽略变量类型）
x===y //判断是否严格相等（计算变量类型）
x!=y //判断是否不相等（忽略变量类型）
x!==y //判断是否严格不相等（计算变量类型）
xy //判断是否大于
x>=y //判断是否大于或者等于*/
/*ps：undefined和null与自身严格相等。*/
var value1; var value2;
console.log(value1===value2;);//true
/*4.逻辑运算符：
逻辑运算符用于测定变量或值之间的逻辑。常见的布尔运算符有以下三种：
非运算符（!）
表达式的值为假的时候，运算结果为真
与运算符（&&）
当运算符两端的表达式值均为真时，运算结果为真，否则为假
或运算符（||）
当运算符两端的表达式值有一个为真，运算结果为真，都为假时结果才假*/
/*5.三目运算符：
三元条件运算符用问号（？）和冒号（：），分隔三个表达式。如果第一个表达式
的布尔值为true，则返回第二个表达式的值，否则返回第三个表达式的值。
语法：表达式1?表达式2:表达式3;
*/
var min = (a<b)?a:b;
4.分支语句
分支语句
顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再
选择的问题就要使用分支结构。
1.分支结构的执行是依据一定的条件选择执行路径，而不是严格按照语句出现的物理
顺序。
2.分支结构的程序设计方法的关键在于构造合适的分支条件和分析程序流程，根据不
同的程序流程选择适当的分支语句。
分支语句通常有以下几种：
- if条件语句
- if else条件语句
- if else if else条件语句
- switch语句
if条件语句
/*先判断一个表达式的布尔值，然后根据布尔值的真伪，执行不同的语句。
语法：if（表达式）{
语句；
}
*/
if (m === 3) {
console.log(“你居然猜到了m变量的值！”);
console.log(“你果然是最帅得，frank大人！”);
}
//这个结构表示当表达式m===3为真的时候，执行if结构内部的语句，否则就不执行。
/*ps：
1.表达式必须放在小括号之中。执行语句必须放在大括号内。
2.if条件语句最后不用加分号。
3.执行语句如果只有一句，那么大括号可以不写。但是推荐所有情况都加上大括号。
*/
if else条件语句
/*if else语句可以认为是if语句的升级版本。判断表达式值的真伪，若结果为真则执行语句1，否则就执行语句2。
语法：if（表达式）{
语句1；
}else{
语句2；
}*/
if ( xiaoHong === “cuteGirl”) {
console.log(“既然小红是个可爱的小女孩，那么奖励你一套花裙子吧”);
}else{
console.log(“虽然小红不可爱，但是蜀黍还是请你吃棒棒糖！嘿嘿嘿！”)；
}
//当表达式结果为真时，打印花裙子。否则请吃棒棒糖。
if else if else条件语句
/*当我们需要对一个变量判断多次的时候，我们就可以使用此结构进行判断。可以认为if elseif else结构是多个if else结构的嵌套。
语法：if（表达式1）{
语句1；
}else if（表达式2）{
语句2；
}else if（表达式3）{
语句3；
}else{
语句4；
}
*/
//ps：else语句不能单独存在，他总是向上匹配离他最近的if语句。
if ( xiaoHong === “cuteGirl”)
{
console.log(“小红是个可爱的小女孩，那么奖励你一套花裙子吧”);
}
else if ( xiaoHong === “sexyGirl”)
{
console.log(“小红是个性感的小女孩，那么奖励你一双高跟鞋吧”);
}
else if ( xiaoHong === “goodJobGirl”)
{
console.log(“小红是个爱工作的小女孩，那么奖励你一台笔记本吧”);
}
else
{
console.log(“小红…恩，继续努力的好好活下去吧！”);
}
switch条件语句
/*switch语句和if语句表达的含义基本相同。其实switch语句很像if else if else结构。
语法：switch（表达式）{
case 结果1：{执行语句1};
break;
case 结果2：{执行语句2};
break;
default：{执行语句3};
}
上面语法结构表达的含义是：
1.判断表达式值是否和结果1相等，如果相等就执行语句1，然后跳出switch结构。
2.否则判断表达式值是否和结果2相等，如果相等就执行语句2，然后跳出switch结构。
3.如果表达式的值与上述case中的结果都不相等，那么直接执行default中的语句，然后结束switch结构。*/
switch (xiaoHong)
{
case "cuteGirl":{console.log("小红是个可爱的小女孩，那么奖励你一套花裙子吧");};
break；
case "sexyGirl":{console.log("小红是个性感的小女孩，那么奖励你一双高跟鞋吧")；};
break；
case "goodJobGirl":{console.log("小红是个爱工作的小女孩，那么奖励你一台笔记本吧")； };
break；
default:{console.log("小红…恩，继续努力的好好活下去吧！")；};
}
ps:
1.case语句和default语句中间的冒号不能省略，必须存在。
2.break语句表示此判断结束，也必须存在。否则一次判断结束会继续进行下一次判断，直到结束为止。
5.循环语句
在不少实际问题中有许多具有规律性的重复操作，因此在程序中就需要重复执行某些语句。
一组被重复执行的语句称之为循环体
能否继续重复的条件称之为循环的终止条件。
循环语句是由循环体及循环的终止条件两部分组成的。
循环结构通常有以下几种：
- while循环
- do while循环
- for 循环
/*(1)while循环
while循环包括一个循环条件和一段代码块。事先不知道要循环多少次，只要条件为真，就不断循环执行代码块，直到条件为假为止。
语法：while (表达式) {
语句；
}
*/
//例：
var i = 0;
while(i < 100){
console.log("i当前为："+i);
i++;
}
//每次循环执行打印当前i所表示的值，直到循环100次后i=100时为止
/*while循环的注意事项：
1.因为while循环是先判断循环条件的，因此while循环的最少执行次数为0。
2.while循环之所以能结束，是因为每次循环执行的过程中都会改变循环变量。
3.执行while循环之前，必须给循环变量设初值。
4.和if条件语句一样，如果while循环体中只有一条语句，那么大括号可以不写。当然我不推荐。
6.while循环结构末尾不需要加分号。
*/
var i = 0; //为循环变量设初值
while(i < 100){
console.log("i当前为："+i);
//i++;
}
/*上述例子如果没有在循环体中改变循环变量的语句，那这个while循环就变成了一个无限循环。也叫死循环。
ps：循环条件恒成立的循环被称为死循环。
(2)do while循环
do while循环和while循环结构基本相同。唯一不同的是do while循环会先将循环体执行一遍后在进行判断。
语法： do{
语句；
} while (表达式) ;
*/
//例：
var i = 0;
do{
console.log("i当前为："+i);
i++;
} while(i < 100);
/*do while循环的注意事项：
1.因为do while循环是先执行循环体，因此do while循环不管循环条件真假，最少执行次数为1。
2.do while循环之所以能结束，是因为每次循环执行的过程中都会改变循环变量。
3.如果循环体中只有一条语句，那么大括号可以不写。当然我不推荐。
4.do while循环结构末尾必须加分号！
例：*/
var i = 0;
do{
console.log("i当前为："+i);
i++;
} while(i < 100);
/*(3)for循环
for循环是循环中使用的较为广泛的一种循环结构。
for循环分两种，一种叫做标准for循环，一种叫做快速遍历。而我们通常意义上的for循环指的是标准for循环
语法： for(表达式1；表达式2；表达式3){
循环体;
}
*/
for(var num = 0; num<10; num++){
console.log(num);
}
/*上述代码的含义是：
1.首先执行表达式1，进行循环变量num的初始化
2.然后判断表达式2结果是否为真，如果为真，执行循环体。否则就跳出循环。
3.当表达式2结果为真，并且循环体执行完毕后，执行表达式3，然后重复步骤b。
for(表达式1; 表达式2; 表达式3) {
循环体；
}
表达式1：确定循环的初始值，只在循环开始时执行一次。
表达式2：检查循环条件，只要为真就进行后续操作。
表达式3：完成后续操作，然后返回上一步，再一次检查循环条件。
for循环的注意事项：
*/
/*1.for循环表达式1可以不写。如果不写表达式1，则需要在循环结构外为循环变量赋初值。*/
var num = 0;
for(;num<10; num++){
console.log(num);
}
/*2.for循环表达式2可以不写。如果不写表达式2，则表示循环条件恒成立。(死循环)*/
for(var num = 0; ;num++){
console.log(num);
}
/*3.for循环表达式3可以不写。如果不写表达式3，则需要在循环结构内部为循环变量增加改变条件*/
for(var num = 0; num<10;){
console.log(num);
num++;
}
break和continue语句
/*break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行。
break语句用于跳出代码块或循环，循环终止。
continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环，循环不终止。
*/
//break实例
var i = 0;
while(i < 100){
console.log(“i 当前为：”+i);
i++;
if(i == 10){
break;
}
}
/*循环执行到第10次的时候，
break执行，跳出整个while循环。*/
//continue实例
var i = 0;
while(i < 100){
console.log(“i 当前为：”+i);
i++;
if(i == 10){
continue;
}
}
/*循环执行到第10次的时候，
continue执行，跳出当前次循环。*/
6.数组
数组的概念
数组(array)是按照一定顺序排列的一组值，每个值都拥有自己的编号，编号从0开始。
整个数组用方括号来表示。
语法：var arr = [item1,item2,item3];
上述代码中的item1、item2和item3元素就构成一个数组。两端的方括号是数组的
标志。因为数组元素编号从0开始，所以item1是数组的第0个元素。
注意：item1、item2和item3是泛指，javascript中的数组元素可以是任何类型的数据。
数组的特点
- 数组的本质
- 数组的长度
- 数组的遍历
- 数组的空位
- 数组的删除
数组的本质
本质上，数组是对象类型的一种特殊表现形式。因此创建的时候我们可以使用new方式来
创建。
var nameArr = new Array('LiLei', 'HanMeiMei', 'Poliy');//['LiLei',
'HanMeiMei', 'Poliy']
typeof运算符会返回数组的类型是object。typeof nameArr// "object"
数组的长度
要讨论数组的长度问题就要搞清楚数组在内存中的存放方式。
前面我们说过，javascript中的数组元素可以是任何数据类型的。而在计算机中不
同的数据类型数据是放在不同存储区的。举例来说：
因此javascript中的数组元素是在内存中的存储位置不连续的。
总结：javascript数组在内存中的存储位置是不连续的，但是数组的下标是连续的。
数组的遍历
//如果想要连续访问数组中的每个元素，可以使用for in快速遍历。
var heroArr = ['GreenJuPeople','BlackGuaFu','MetalXia'];
for(var index in heroArr){
console.log(heroArr[index]);
}
GreenJuPeople
BlackGuaFu
MetalXia
ps：需要引起注意的是，for in循环遍历数组的时候，for循环中的index表示的数组的
下标。并不是表示数组元素！
数组的空位
/*当数组的某个位置是空元素，即两个逗号之间没有任何值，我们称该数组存在空
位(hole)。*/
var countryNameArr = ['China','','Japan'];
countryNameArr.length//3
/*有趣的是：如果最后一个元素后面有逗号，这种情况并不会产生空位。也就是说最
后一个元素后面的逗号有和没有结果都是一样的。(当然这种写法并不推荐。)*/
var countryName = ['China','American','Japan',];
countryName.length//3
数组的删除
/*delete命令能够删除数组中的元素的值，从而形成空位。但是delete命令并不会影响
length的属性。*/
var girlFriends = ['ZhangTianAi','LiuShiShi','SomeOne'];
delete girlFriends[1];
console.log(girlFriends.length);//3
console.log(girlFriends); //["ZhangTianAi", 2: "SomeOne"]
/*ps：delete命令在使用的时候，是根据数组下标来对指定数组的值进行删除的。*/
数组的调用
/*数组的调用实际上指的是数组元素的调用。数组元素通过【数组名+下标】的方式来进行访问。*/
var girlFriends = ['张天爱','李贞贤','SomeOne'];
console.log('今天朕就选你侍寝吧，'+girlFriends[0]);
console.log('张天爱：爱死你了皇上')
/*ps：数组元素一次只能访问一个，不能一次连续访问多个数组元素。*/
数组的方法
javascript为数组提供了很多方法，方便开发者更好的使用数组。
isArray:判断是否为数组
valueOf:返回数组本身
toString:将数组以字符串的形式返回
push:向数组末尾追加数据,返回当前数组的长度
pop:删除数组最后一个元素
join:将数组转换为字符串，默认按逗号隔开
shift(): 在数组头部删除一个元素
unshift():在数组头部添加一个元素
reverse():数组反转
slice:数组截取
splice:数组截取，并且可以插入新的元素(改变原数组)
sort：排序
indexOf:索引
lastIndexOf:反序索引
二维数组
如果数组的元素还是数组，那么我们就称外层数组是一个二维数组。
语法：var arr = [[item1,item2],[item3,item4]];
var arr = [[1,2],[3,4]];
arr[0][1] = 2;
arr[1][0] = 3;
二维数组的调用很简单，有两个下标。第一个下标表示外层数组的下标，第二个下标表示内层数组的下标。尝试解释上述例子中调用二维数组的原理。
ps：二维数组是数组的一种特殊形式，数组的方法对二维数组仍然生效。
7.对象和函数
javascript对象
/*对象（object）是大括号定义的无序的数据集合，由键值对构成，键与值之间用冒号
分隔，大括号末尾要使用分号表示对象定义结束。
对象是JavaScript的核心概念，也是最重要的数据类型。JavaScript的所有数据
都可以被视为对象。此外，JavaScript 允许自定义对象。
语法：*/
var obj = { key : value };
/*上面代码定义了一个对象，它被赋值给变量obj。
key是“键名”
value是“键值”
ps:如果对象内部包含多个键值对，每个键值对之间用逗号分隔。最后一个键值对末尾不用加逗号
*/
var obj = {key1:value1,key2:value2};
键名(对象的属性)
/*
键名也被称为属性(property)，对象的所有属性都是字符串，所以加不加引号都可以。
因此上面的代码也可以写成下面这样：*/
var obj = { 'key': value };
/*但是，如果属性不符合标识符的条件(比如第一个字符为数字，或者含有空格或运算符)，则必须加上引号。*/
var obj = {
'1p': "Hello World",
'h w': "Hello World",
'p+q': "Hello World"
};
/*上面对象的三个属性，都不符合标识名的条件，所以必须加上引号。
ps:JavaScript的保留字可以不加引号直接当作对象的属性。*/
键值
//键值是属性所对应的具体的值。javascript的对象的键值可以是任何数据类型。
var frank = {
name: "Frankenstein Add",
age: 18,
sex: "male"
ability: eat();//eat()表示函数
};
//ps：如果一个属性的值(ability)为函数，通常把这个属性称为“方法”。它可以
//像函数那样调用这个属性。
frank.ability();
对象的创建
/*a.直接使用大括号创建对象
b.使用new命令生成一个Object对象的实例
c.使用Object.create方法创建对象*/
var obj1 = {};
var obj2 = new Object();
var obj3 = Object.create(null);
/*上面三行语句是等价的，都表示创建了一个没有键值对的空对象。
ps：一般来说，第一种采用大括号的写法比较简洁，也是最常用的一种创建对象的写法。第二种采用构造函数的写法清晰地表示了意图，第三种写法一般用在需要对象继承的场合。*/
对象属性的读写
a.读取属性
读取对象的属性,有两种方法:一种是使用点运算符,还有一种是使用方括号运算符。
语法：var obj = { key：value }；
console.log(obj.key);
console.log(obj['key']);
var frank = { name: 'Frankenstein' };
console.log(frank.name);//Frankenstein
console.log(frank['name']);//Frankenstein
ps:需要注意的是，使用方括号读取对象属性的时候需要加引号！
b.写入属性
点运算符用来为对象的属性写入值。
语法：var obj = {}；
obj.key = value;
console.log(obj.key);
var frank = {};
frank.name = 'frank';
console.log(frank['name']);//frank
ps：点运算符和中括号运算符都能够给对象的属性赋值,无论属性是否存在(修改属性值)。
对象属性的操作
javascript为对象提供了一系列内置的方法，方便我们更好的操作对象。
Object.keys()获取对象所有属性
delete删除一个属性
in检查对象是否包含一个属性
for in遍历对象所有属性
with操作多个对象属性
Object.keys()获取对象所有的属性,返回一个属性构成的数组
var greenJuPeople = { name: '绿巨人', ability:'发怒变绿' };
console.log(Object.keys(greenJuPeople));//["name", "ability"]
ps：Object.keys()是一个整体，调用的时候必须整体使用。
【delete】从对象中删除一个属性
语法：delete obj.property
var obj = { key : 'value' };
Object.keys(obj); // ["key"]
delete obj.key; // true
obj.key; // undefined
Object.keys(obj); // []
上面代码表示，一旦使用delete命令删除某个属性，再读取该属性就会返回undefined，而且Object.keys方法返回的该对象的所有属性中，也将不再包括该属性。
ps:如果删除一个不存在的属性，delete不报错，而且返回true。千万引起注意！
var obj = {};
delete obj.key; // true
【in】检查对象是否包含一个属性
语法：'key' in obj
var obj = { key : 'value' };
console.log( 'key' in obj );//true
console.log( 'value' in obj);//false
ps:检查的是键名，不是键值。如果包含就返回true，否则返回false。
【for in】遍历对象的所有属性
语法：var obj = { key1:value1, key2:value2, key3:value3 };
for (var pro in obj){
console.log(obj[pro]);
}
ps:循环变量pro表示的是对象的属性名，并不表示属性的值！千万注意！！！！！！
【with】同时操作一个对象的多个属性
语法：with(obj){
key1 = value1;
key2 = value2;
}
var frank = { name : '', age : 0 };
with(frank){
name = 'frank'; age = 18;
} console.log(frank.name+frank.age);
ps:with只能够修改对象中已经存在的属性，对于对象中原本不存在的属性with无能为
力。ps:with对于ES6以及ES5中的严格模式都已经禁用了，因为with可能会导致代码更
难调试和读取。
对象的引用
如果不同的变量名指向同一个对象，那么它们都称为这个对象的引用。
也就是说这些变量共同指向同一个内存地址，修改其中一个变量所指向的值，都会影响到其他所有变量所指向的值。
var obj = { fire : 'burn' };
var people1_fire = obj;
var people2_fire = obj;
obj.fire = '灭了';
console.log(people1_fire.fire);//灭了
console.log(people2_fire.fire);//灭了
javascript函数
函数是由事件驱动的或者当它被调用时执行的可重复使用的代码块。
语法：
function 函数名(函数参数1,函数参数2,..) {
函数内容语句//函数体
}
function baoZi(){
console.log('和面');
… console.log('包子出锅'); }
上述代码把刚才函数示意图中的机器用代码的方式表示了出来，能够看到每次调用baoZi函数的时候都能够得到一个包纸。
ps:函数参数我们先暂且不考虑，可以不写。
函数的声明
【function命令】
语法：function 函数名(参数1,参数2,…){ 函数体 }
function命令后面是函数名，函数名后面是一对圆括号，里面是传入函数的参数。函数体放在大括号里面。这种方式声明的函数可以通过调用函数名来调用函数。
【函数表达式】
语法：var 变量 = function(参数1,参数2,…){ 函数体 };
这种声明函数的方式没有函数名，而是用变量来指代函数。调用函数的时候通过访问变量来调用函数。
【Function构造函数】
语法：var 变量 = new Function();
这种声明函数的方式非常不直观，几乎无人使用。
函数的调用
相较于函数声明的多种多样，函数的调用方式就简单很多。通常情况下只要函数
已经被声明，直接写出函数名和函数参数即可调用函数。
function baoZi(){console.log('这是做包子的机器');} baoZi();//这是
//做包子的机器
var jiuCaiBox = function(){console.log(‘这是做韭菜盒子的机器’);}
jiuCaiBox();//这是做韭菜盒子的机器
ps：很显然通过调用能够看到，多次重复声明同名的函数会造成的结果就是：
后声明的函数会覆盖先声明的函数。
ps：对于javascript来说，把函数调用写在函数声明之前也是被允许的，因为javascript
存在一个隐式的函数提升。
函数的类型
【无参无返回值】类型函数：function eat(){}
【无参有返回值】类型函数：function eat(){return '吃的包子';}
【有参无返回值】类型函数：function eat('包子'){}
【有参有返回值】类型函数：function eat('包子'){return '吃的包子'}
名词解释
返回值：【函数执行结束后】返回到【原本程序中函数所在的位置】,用来替代整个
函数的【结果】，被称为函数的返回值。通常使用return关键词来实现。
形式参数：函数在定义的时候写在小括号中的参数被称为形式参数。形式参数只用
来在函数内部使用，在函数外部形式参数失效。通常形式参数不用var声明，直接写
变量名即可。
实际参数：函数在调用的时候写在小括号中的参数被称为实际参数。
函数的作用域(scope)
作用域（scope）指的是变量存在的范围。Javascript只有两种作用域：
全局作用域：变量在整个程序中一直存在，所有地方都可以读取。
函数作用域：变量只在函数内部存在。在函数外部变量失效。
和作用域与之对应的，javascript中有两种变量：
全局变量(global variable)：在函数外部声明的变量，它可以在函数内部读
取。
局部变量(local variable)：在函数内部定义的变量，外部无法读取。
var globle_variable = 1;
function func_globle(){console.log(globle_variable);}
func_globle();//1
function func_local(){var local_variable = 1;}
console.log(local_variable);//local_variable is not defined
函数的补充说明
a.ECMAScript规定:不能在非函数的代码块中声明函数。
if(a>0){
function func(){}//wrong way!
}
b.可以使用name属性来获取函数名(个人觉得暂时没啥用) function func() {}
func.name // ‘func'
c.可以使用length属性来获取函数的参数个数
function func(num1, num2) {}
func.length // 2
d.函数中还有一种特殊的函数，叫做自执行函数
(function(){ /* code */ }()); 或 (function(){ /* code */ })();
其特点就是不需要调用就能够自动执行。
闭包
闭包：能够读取其他函数内部变量的函数。
在本质上，闭包就是将函数内部和函数外部连接起来的一座桥梁。
闭包的最大用处有两个：
一个是可以读取函数内部的变量，
另一个就是让这些变量始终保持在内存中，即闭包可以使得它诞生环境一直存在
function changeNum(start) {
return function () {
return start++;
};
}
var inc = changeNum(5);
inc() // 5
inc() // 6
inc() // 7