1、什么是函数?

1、函数是一个可以多次使用的功能代码块,一个封闭的(空间),它可以在代码里随意调用。利用函数的封装可以减少重复代码的开发,提高代码的利用率。函数可以传参,利用函数内预先定义的内容对传入的不同数据参数进行处理。

2、函数也是对象,也可以为值,它可以存在于变量,数组和对象之中。

3、函数可以当参传递给函数,并且由函数返回,另外函数拥有属性。

4、函数总会有返回值(除了构造函数之外,构造函数默认返回构造器函数调用,当构造函数调用执行时,会显示返回)

函数的方法:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
let functionA = function() {
console.log('这是一个匿名函数,赋值给变量functionA')
}

let functionB = []
functionB.push(function() {
console.log('这是一个匿名函数,存放在数组functionB中')
})

let functionC = {
mh: function() {
console.log('这是一个匿名函数,粗放在对象functionC中')
}
}
函数的调用:
1
2
3
functionA()     // 普通函数的调用
functionB[0]() // 函数在数组中的调用
functionC.mh() // 函数在对象中的调用
函数可以作为参数进行传递并可以作为返回值进行返回
1
2
3
4
5
6
7
8
let functionD = function(funParms) {
retrun funParms
}

let returnFunParms = functionD(function() {
console.log('这是一个将函数当做参数传递的例子')
})
returnFunParms() // 这是一个将函数当做参数传递的例子
函数也是对象,也就是说函数也拥有属性
1
2
3
4
5
6
7
let funNative = function() {}
funNative.property = '小夭同学'

funNative.property // 小夭同学
typeof funNative // "function"
funNative instanceof Object // true
funNative.constructor // ƒ Function() { [native code] }

2、什么是构造函数

构造函数就是用【new】关键字来实例化对象的函数,或者是new关键字调用的普通函数,任何函数都可以作为构造函数存在。构造函数定义时首字母大写。

1
2
3
作用:用来初始化对象并为其添加属性和方法,以方便创建大量相同类型的对象,利于使用继承等高级特性。

缺点:实例化多个对象的时候会重复的创建对象,造成内存空间浪费,增大CPU消耗。

Demo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function Bcx() {
this.text = '公众号:小夭同学'
this.method = () => {
console.log(this.text)
}
}

let oo = new Bcx()

new操作符调用一个构造函数的时候发生以下:

let obj = {}
obj._proto_ = Bcx.prototype
Bcx.call(obj)
return obj

1、创建一个空对象 obj
2、将这个空对象的_proto_成员指向了构造函数对象的prototype成员对象
3、将构造函数的作用域赋给新对象,因此Bcx函数中的this指向新对象obj,然后再调用Bcx函数。
4、返回新对象obj。

注意:

当构造函数中没有返回对象时候,最终new出来的对象会是构造函数的返回值,而不是new过程中生成的对象。仅当构造函数返回值是对象时有效,当不是对象时依旧返回new过程中形成的对象(无论如何new构造函数之后都会返回一个对象值)

构造函数也可以当做普通函数来调用

其他:

1
2
3
4
5
当任意一个普通函数用于创建一类对象时,它就被称作构造函数或构造器。一个函数要作为真正的构造函数有如下条件:

1、在函数内部对新对象(this)的属性进行设置,通常是添加属性和方法。

2、构造函数可以包含返回语句(不推荐),但返回值必须是this,或者其他非对象类型的值。

普通函数和构造函数的区别

1
2
3
1、普通函数没有new,构造函数有
2、构造函数首字母大写(区分普通函数和构造函数)
3、当函数没有被new调用时,构造函数中的this就指向全局对象的window

3、原型对象

prototype

1、改下对象下面公用的方法或者属性,让公用方法或者属性在内存中存在一份,可以被其他对象调用

2、在原有对象的基础上,通过prototype进行额外的封装、拓展

示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// 普通写法
let a1 = [1,2,3,4,5]
let a2 = [2,4,5,6,7]

a1.sum = function() {
let temp = 0;
for(let i = 0; i< a1.length;i++) {
temp += this[i]
}
return temp
}
a2.sum = function() {
let temp = 0;
for(let i = 0; i< a2.length;i++) {
temp += this[i]
}
return temp
}
console.log(a1.sum(),a2.sum()) // 15 24

// 原型写法
let a1 = [1,2,3,4,5]
let a2 = [2,4,5,6,7]

Array.prototype.sum = function() {
let temp = 0;
for(let i = 0; i< this.length;i++) {
temp += this[i]
}
return temp
}
console.log(a1.sum(),a2.sum()) // 15 24

// 闭包写法
let a1 = [1,2,3,4,5]
let a2 = [2,4,5,6,7]

function sum(arr) {
let temp = 0;
for(let i = 0; i< arr.length;i++) {
temp += arr[i]
}
return temp
}
console.log(sum(a1),sum(a2)) // 15 24

注意:

当构造函数自定义属性名与该构造函数下原型属性名相同时,构造函数的自定义属性优先于原型属性(可以把构造函数理解为内联样式),而原型属性或原型方法可以看做class.

总结:

构造函数就是用new关键字调用的普通函数,可以随时定义自己的构造函数来创建多个具有同样属性的对象,我们可以用instanceof来鉴别对象是被哪个构造函数创建的。每一个函数都具有prototype属性,它定义了构造函数所有对象的共享属性。

1、自定义的属性和方法放在构造函数里面

2、共享的属性和方法挂载在该构造函数的原型下面

3、js查找变量的机制,是沿着作用域链逐级向上查找,在原型里–>是原型链,构造函数与原型之间的连接就是原型链。当访问对象的属性时,js首先在自定义的属性的作用域内查找改变量是否存在,如果不存在,则会沿着原型链向原型下的属性中查找该属性,直至顶层Object的原型对象,若是找到则返回,找不到则返回undefined。