<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// function add (){
// var a = 3;
// return a
// }
//一般情况下，函数声明的局部变量，在函数调用完之后就会被销毁掉
// console.log(add())
// add()
//
//
// function add(){
// var a = 3
// return function(){
// return a
// }
// }
//
// abc = add()
// console.log(abc())
//闭包的好处
// var list = [f0,f1,f2]
// f0()---->0
// f1()---->1
// f2()---->2
//假设需要一个列表，这个列表存放n个函数，只要调用list[i](),那么就会返回i
//-----------------------------------案例1：
// var list = []
//
// for(var i=0;i<3;i++){
// var temfn = function(){
// return i
// }
// list.push(temfn)//将函数添加进列表
// }
//
// console.log(list)
// list[0]() //====> 3
//----------------------------------案例1：解决方案
var list = []
for (var i=0;i<3;i++){
//匿名函数通过自己调用自己执行，获取i值传入num参数
//num参数这个变量被返回的匿名函数所引用，所以参数num不会被销毁，使得num参数可以保留。
var temfn = (function(num){
return function(){
return num
}
})(i)
list.push(temfn)
}
// console.log(list[0]())
function Counter(){
var num = 0
return function(){
num ++
return num;
}
}
var abc = Counter()
console.log(abc())
console.log(abc())
console.log(abc())
//能不用闭包，就尽量不用闭包，因为会导致内存的可使用量下降（内存泄漏）
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script type="text/javascript">
// a = add(3,4)
// console.log(a)
//将一个匿名函数给到1个变量
// var add = function(a,b){
// a = a + 1;
// b = b + 1;
// return a+b
//
// console.log(123)
// }
//直接申明函数的方式
// function add (a,b){
// a = a + 1;
// b = b + 1;
// return a+b
// }
//注意：直接申明函数的方式，浏览器会自动将它提升到最前面。
//js不会对函数的参数进行检查
// a = add()
// console.log(a)
//
//返回值通过return返回出去，return语句执行之后，不会再继续执行函数后面的内容。
// function add(a=3,b=4){
// console.log(a,b)
// a = a + 1;
// b = b + 1;
//
// return a+b
// }
function add(a,b){
if(a==undefined){
a = 3
}
if(b == undefined){
b = 4
}
a = a + 1;
b = b + 1;
return a+b
}
console.log(add())
var student = {name:'xx',age:16}
function abc(){
//在函数里面，用var申明使这个函数的局部变量，在其他地方是拿不到的
var num = 3
var student = {name:'666'}
return student.name
}
console.log(abc())
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script type="text/javascript">
//1、字面量的方式,偶尔创建一个特定的对象，那么就是最简单和便捷方式
var student = {
name:'xx',
age:'xx'
}
//2、构造函数的方式
var student = {}//构造一个新的空对象
var student = new Object()//构造一个新的空对象
student.name = 'xx'
student.age = 'xx'
//3、创建一个函数来构造一个对象，工厂模式
function Student(name,age){
var student = {}
student.name = name;
student.age = age
return student
}
var s1 = Student('xx','xx');
var s2 = Student('mingzi','nianling')
//4、构造一个构造函数，通过构造函数，实例化一个对象
function Student(name,age){
this.name = name;
this.age = age
this.showName = function(){
console.log(this.name)
}
//没有返回值
}
var s3 = new Student('gzhanshu','xxx')
//如果使用了new 调用函数，那么首先会创建1个对象，并且将这个对象赋值s3,如果函数里有this,那么这个this就是这个新创建的对象
var s4 = Student('yyy','uuu')//如果没有new，就是一个普通函数，那么普通函数没有返回值，就是未定义
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script type="text/javascript">
//构造一个构造函数，通过构造函数，实例化一个对象
function Student(name,age){
this.name = name;
this.age = age
console.log(name)
//没有返回值
}
function Man(){
this.run= function(){
console.log('会跑')
}
this.showName = function(){
console.log(this.name)
}
}
var man = new Man()
//设定构造函数对象的属性prototype,将原型对象给到这个prototype属性
Student.prototype = man
var s3 = new Student('gzhanshu','xxx')
//原型对象也可以有原型，那么原型的原型所形成的链式，那么就叫做原型链
//原型里面属性方法可以被，实例化的对象共享。大大的减少内存的消耗
</script>
</body>
</html>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<script type="text/javascript">
//对象也存放一组数据的地方
//student,学生姓名，学生年龄，会考试，会读书，会唱歌
//字面量的方式
var student = {
name:'老王',
age:'30',
dizhi:'隔壁',
isMan:true,
son:{name:'xiaowang',age:3},
action:function(){
console.log('拐卖良家妇女')
}
}
console.log(student)
//想要获取里面的属性
// student['属性值']
// student.属性值
// 我们如果想要用变量的情况下，那么就要用中括号。
// student.xuehao = 123456789
// student['xuehao'] = 12432342
// console.log(student)
var student2 = new Object()
student2.name = 'xxzz'
student2.age = 16
console.log(student2)
</script>
</body>
</html>
