JS深入浅出Function与构造函数

var f = function () {
  console.log('this is f function');
}
// 函数也是一个对象
console.log(f instanceof Object); // true
// 函数是Function类型的对象
console.log(f instanceof Function); // true

var functionName = new Function ([arg1[, arg2[, ...argN]],] functionBody)

// 无参的函数
var fun = new Function('console.log("这是一个函数")')
fun() // 这是一个函数
// 带一个参数的函数
var fun = new Function('a', 'console.log("这个函数带一个参数：" + a)')
fun(100) // 这个函数带一个参数：100
// 带两个参数的函数
var fun = new Function(
  'a, b',
  'console.log("这是带两个参数的函数，分别是" + a + "和" + b);',
)
fun(100, 200) // 这是带两个参数的函数，分别是100和200

console.log(Function instanceof Function) //true
console.log(Function instanceof Object) //true
console.log(Object instanceof Object) //true
console.log(Object instanceof Function) //true

function Person(){
  this.属性名 = 属性值;
  this.方法名 = function() {
      方法体
}
var person = new Person();

// 自定义构造函数 -> 作用：创建对象
function Person(name, age, sex) {
  this.name = name
  this.age = age
  this.sex = sex
  this.print = function () {
    console.log(name + '今年' + age + '岁 性别' + sex)
  }
}
// 创建 一碗甜
var t = new Person('一碗甜', 18, '女')
hong.print() // 一碗甜今年18岁 性别女
// 创建 一碗周
var z = new Person('一碗周', 20, '男')
dong.print() //一碗粥今年20岁 性别男

// 创建 一碗周
var z = new Person('一碗周', 18, '男')
// 判断是否为 Person 构造函数的对象
console.log(z.constructor === Person)

function Hero() {
  // 当作是一个函数来使用
  var v = 100 // 局部变量
  // 当作是一个构造函数来使用
  this.set = function (value) {
    v = value
  }
  this.get = function () {
    return v
  }
}

// 直接调用
Hero()
// 通过构造函数创建对象
var hero = new Hero()
// 当做对象为其添加属性和方法
Hero.n = '一碗周'
console.log(Hero.n) // 一碗周

// 定义两个空函数
function fun(a, b, c, d) {}

function fn() {}

// 测试 length 属性
console.log(fun.length) // 4
console.log(fn.length) // 0

func.apply(thisArg, [argsArray])

// 定义一个函数
function fn(a) {
  console.log('this is ' + a)
}
fn.apply(null, ['函数']) // this is 函数

// 上面的调用方式等同于下面这种方式
fn('函数') // this is 函数

function fn(a) {
  console.log('this is ' + a)
}
fn.call(null, '函数') // this is 函数

// 上面的调用方式等同于下面这种方式
fn('函数') // this is 函数

function.bind(thisArg[, arg1[, arg2[, ...]]])

// 定义一个函数
var fun = function (a, b) {
  console.log('第一个参数的值为：' + a + '第二个参数的值为：' + b)
}
// 调用 fun()
fun(10, 20) // 第一个参数的值为：10第二个参数的值为：20
// 创建绑定函数
var fn = fun.bind(null, 100, 200) // 有参数默认值的功能
// 调用新创建的函数，不写实参
fn() // 第一个参数的值为：100第二个参数的值为：200

/*
 * arguments 对象是一个存在于函数体中的特殊对象。
 * arguments 对象是一个类数组对象
 * arguments 对象对应传递给函数的实参
 */
// 定义一个函数
var fun = function () {
  console.log(arguments)
  // arguments.callee  指向参数所属的当前执行的函数。
  //如果给这个属性加一个括号则表示调用。因为 arguments.callee === fun 的结果为 true
  console.log(arguments.callee)
  // arguments.length  传递给函数的参数数量。
  console.log(arguments.length)
}
fun(1, 2, 3, 4, 5) 

[Arguments] { '0': 1, '1': 2, '2': 3, '3': 4, '4': 5 }
[Function: fun]
5

// 模拟函数的重载
function add() {
  // 记录参数数量
  var len = arguments.length
  // 通过 switch case 语句判断传入参数数量，来模拟重载的功能
  switch (len) {
    case 2:
      return arguments[0] + arguments[1]
      break
    case 3:
      return arguments[0] + arguments[1] + arguments[2]
      break
    case 4:
      return arguments[0] + arguments[1] + arguments[2] + arguments[3]
      break

    default:
      break
  }
}
console.log(add(1, 2)) // 3
console.log(add(1, 2, 3)) // 6
console.log(add(1, 2, 3, 4)) // 10