递归和闭包

Echo.857

已于 2022-08-18 20:07:15 修改

阅读量134

点赞数

文章标签： javascript 前端开发语言

于 2022-08-18 19:14:08 首次发布

本文链接：https://blog.csdn.net/weixin_70140069/article/details/126412171

版权

原型链

面向对象编程

ES5实现

function Star(uname, height, weight) {
    this.uname = uname;
    this.height = height;
    this.weight = weight

    this.say = function () {
        console.log(`我是${this.uname}，我身高${this.height}厘米，体重${this.weight}公斤`)
    }
}

var ldh = new Star("刘德华", 174, 64)
ldh.say()

var lyf = new Star("刘亦菲", 170, 80)
lyf.say()

定义一个构造函数Circle，里面有两个方法area和length，分别计算圆的面积和周长

ES6实现

//定义一个类
class Star {
    //构造函数
    constructor(uname, height, weight) {
        //this指向实例化对象
        this.uname = uname;
        this.height = height;
        this.weight = weight;
    }

    say() {
        return `我是${this.uname}，身高${this.height}厘米，体重${this.weight}公斤`
    }
}

var ldh = new Star("刘德华", 185, 80)
console.log(ldh.say())

定义一个构造函数Circle，里面有两个方法area和length，分别计算圆的面积和周长

class Circle {
    constructor(r) {
        this.r = r
    }

    //计算周长
    length() {
        return (2 * Math.PI * this.r).toFixed(2)
    }

    //计算面积
    area() {
        return (Math.PI * r ** 2).toFixed(2)
    }
}

console.log(new Circle(4).length())
console.log(new Circle(4).area())

ES6继承

// 父类 Person
class Person {
    constructor(uname, age) {

        //属性
        this.uname = uname;
        this.age = age
    }

    //方法
    say() {
        return `我是${this.uname}，我年龄${this.age}岁`
    }
}


//子类Student
class Student extends Person {
    constructor(uname, age) {
        // this.uname = uname;
        // this.age = age;
        super(uname, age)
    }

}


var s1 = new Student("小红", 18)
console.log(s1.say())


//子类Teacher

递归

在一个函数内部调用自身

function fun(){
	fun()
}

阶乘

/*****
     * 递归：在函数内部调用自己
     *        使用递归：一定要有退出条件
     *
     * ******/
var n = 1;
function fun() {
    if (n > 6) return;
    console.log("我喜欢写代码")
    n++
    fun()
}

fun()

求阶乘

// 求阶乘  5!=5*4*3*2*1

function fun(n) {
    if (n == 1) return 1
    return n * fun(n - 1)

}

fun(5)

斐波那契数列


    // 斐波那契数列
    //  1     1      2     3     5       8       13
    // n=1   n=2    n=3   n=4   n=5     n=6      n=7
    function fun(n) {
        if (n == 1 || n == 2) {
            return 1
        }
        return fun(n - 2) + fun(n - 1)
    }
    fun(5)
    console.log(fun(5));

闭包

闭包的定义

有权访问另一个函数作用域中变量的函数

简单理解：一个作用域可以访问另一个函数内部的变量
闭包的原理
闭包的使用场景

字符串常用方法

复制
查找
删除
切割

数组常用方法

字符串和数组的转化
增删改查
数组结构
数组转对象

对象常用方法

对象合并

Object.assgin()
对象解构
对象转数组

进制转换

十进制转二进制
十进制 569 ===>二进制
十进制转八进制
```
 十进制 1000 ===>八进制
```

数据类型检测

<script>
    function checkType() {
      //参数的数量不一定，用arguments全部获取，转换成数组
      var arr = Array.from(arguments)   
      var newArr = []
      arr.forEach(item => {
        //获取类型
        var result = Object.prototype.toString.call(item)
        //截取字符串，添加到数组
        newArr.push(result.slice(8, -1))
      })
      //数组转字符串，用逗号分隔
      return newArr.join(",")

    }

    var result = checkType([], {}, "", 100)
    console.log(result)
  </script>

幂运算

 <script>
    // Math.pow((23+Math.pow(5,7))/45,2)

    // ((23+5**7)/45)**2

    //计算六边形面积
    // function calc(l){
    //    return 3*Math.sqrt(3)/2*l**2
    // }
   
  </script>

位数相加


<body>
  <input type="text" name="" id="">
  <button>点击</button>

</body>
<script>
  var input = document.querySelector("input")
  var button = document.querySelector("button")
  button.onclick = function () {
    var val = parseInt(input.value)     //用户输入的值
    var result = parseInt(val / 100) + parseInt(val % 100 / 10) + val % 10
    alert(result)
  }
</script>

Echo.857

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
递归和闭包

定义一个构造函数Circle，里面有两个方法area和length，分别计算圆的面积和周长。定义一个构造函数Circle，里面有两个方法area和length，分别计算圆的面积和周长。简单理解：一个作用域可以访问另一个函数内部的变量。十进制 1000 ===>八进制。有权访问另一个函数作用域中变量的。十进制 569 ===>二进制。在一个函数内部调用自身。......
复制链接

扫一扫