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

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

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

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

函数的方法：
let functionA = function() {
    console.log('这是一个匿名函数，赋值给变量functionA')
}

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

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

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

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

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

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

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

Demo

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、在函数内部对新对象(this)的属性进行设置，通常是添加属性和方法。

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

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

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

prototype

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

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

示例：

// 普通写法
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。