javascript第三天

最新推荐文章于 2024-07-08 18:01:35 发布
最新推荐文章于 2024-07-08 18:01:35 发布
阅读量433 收藏
点赞数
分类专栏： javascript高级 文章标签： javascript 原型模式 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59708269/article/details/124916944
版权

对象高级

一.Object构造函数模式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_Object构造函数模式</title>
</head>
<body>
<!--
方式一: Object构造函数模式
  * 套路: 先创建空Object对象, 再动态添加属性/方法
  * 适用场景: 起始时不确定对象内部数据
  * 问题: 语句太多
-->
<script type="text/javascript">
  /*
  一个人: name:"Tom", age: 12
   */
  // 先创建空Object对象
  var p = new Object()
  p = {} //此时内部数据是不确定的
  // 再动态添加属性/方法
  p.name = 'Tom'
  p.age = 12
  p.setName = function (name) {
    this.name = name
  }

  //测试
  console.log(p.name, p.age)
  p.setName('Bob')
  console.log(p.name, p.age)
</script>
</body>
</html>

二.对象字面量

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_对象字面量</title>
</head>
<body>
<!--
方式二: 对象字面量模式
  * 套路: 使用{}创建对象, 同时指定属性/方法
  * 适用场景: 起始时对象内部数据是确定的
  * 问题: 如果创建多个对象, 有重复代码
-->
<script type="text/javascript">
  var p = {
    name: 'Tom',
    age: 12,
    setName: function (name) {
      this.name = name
    }
  }

  //测试
  console.log(p.name, p.age)
  p.setName('JACK')
  console.log(p.name, p.age)

  var p2 = {  //如果创建多个对象代码很重复
    name: 'Bob',
    age: 13,
    setName: function (name) {
      this.name = name
    }
  }

</script>
</body>
</html>

三.工厂模式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>03_工厂模式</title>
</head>
<body>
<!--
方式三: 工厂模式
  * 套路: 通过工厂函数动态创建对象并返回
  * 适用场景: 需要创建多个对象
  * 问题: 对象没有一个具体的类型, 都是Object类型
-->
<script type="text/javascript">
  function createPerson(name, age) { //返回一个对象的函数===>工厂函数
    var obj = {
      name: name,
      age: age,
      setName: function (name) {
        this.name = name
      }
    }

    return obj
  }

  // 创建2个人
  var p1 = createPerson('Tom', 12)
  var p2 = createPerson('Bob', 13)

  // p1/p2是Object类型

  function createStudent(name, price) {
    var obj = {
      name: name,
      price: price
    }
    return obj
  }
  var s = createStudent('张三', 12000)
  // s也是Object
</script>
</body>
</html>

四.自定义构造函数模式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>04_自定义构造函数模式</title>
</head>

<body>
<!--
方式四: 自定义构造函数模式
  * 套路: 自定义构造函数, 通过new创建对象
  * 适用场景: 需要创建多个类型确定的对象
  * 问题: 每个对象都有相同的数据, 浪费内存
-->
<script type="text/javascript">
  //定义类型
  function Person(name, age) {
    this.name = name
    this.age = age
    this.setName = function (name) {
      this.name = name
    }
  }
  var p1 = new Person('Tom', 12)
  p1.setName('Jack')
  console.log(p1.name, p1.age)
  console.log(p1 instanceof Person)

  function Student (name, price) {
    this.name = name
    this.price = price
  }
  var s = new Student('Bob', 13000)
  console.log(s instanceof Student)

  var p2 = new Person('JACK', 23)
  console.log(p1, p2)
</script>
</body>
</html>

五.构造函数+原型的组合模式

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>05_构造函数+原型的组合模式</title>
</head>
<body>
<!--
方式六: 构造函数+原型的组合模式
  * 套路: 自定义构造函数, 属性在函数中初始化, 方法添加到原型上
  * 适用场景: 需要创建多个类型确定的对象
-->
<script type="text/javascript">
  function Person(name, age) { //在构造函数中只初始化一般函数
    this.name = name
    this.age = age
  }
  Person.prototype.setName = function (name) {
    this.name = name
  }

  var p1 = new Person('Tom', 23)
  var p2 = new Person('Jack', 24)
  console.log(p1, p2)

</script>
</body>
</html>

六.原型链继承

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_原型链继承</title>
</head>
<body>
<!--
方式1: 原型链继承
  1. 套路
    1. 定义父类型构造函数
    2. 给父类型的原型添加方法
    3. 定义子类型的构造函数
    4. 创建父类型的对象赋值给子类型的原型
    5. 将子类型原型的构造属性设置为子类型
    6. 给子类型原型添加方法
    7. 创建子类型的对象: 可以调用父类型的方法
  2. 关键
    1. 子类型的原型为父类型的一个实例对象
-->
<script type="text/javascript">
  //父类型
  function Supper() {
    this.supProp = 'Supper property'
  }
  Supper.prototype.showSupperProp = function () {
    console.log(this.supProp)
  }

  //子类型
  function Sub() {
    this.subProp = 'Sub property'
  }

  // 子类型的原型为父类型的一个实例对象
  Sub.prototype = new Supper()
  // 让子类型的原型的constructor指向子类型
  Sub.prototype.constructor = Sub
  Sub.prototype.showSubProp = function () {
    console.log(this.subProp)
  }

  var sub = new Sub()
  sub.showSupperProp()
  // sub.toString()
  sub.showSubProp()

  console.log(sub)  // Sub
</script>
</body>
</html>

七.借用构造函数继承

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_借用构造函数继承</title>
</head>
<body>
<!--
方式2: 借用构造函数继承(假的)
1. 套路:
  1. 定义父类型构造函数
  2. 定义子类型构造函数
  3. 在子类型构造函数中调用父类型构造
2. 关键:
  1. 在子类型构造函数中通用call()调用父类型构造函数
-->
<script type="text/javascript">
  function Person(name, age) {
    this.name = name
    this.age = age
  }
  function Student(name, age, price) {
    Person.call(this, name, age)  // 相当于: this.Person(name, age)
    /*this.name = name
    this.age = age*/
    this.price = price
  }

  var s = new Student('Tom', 20, 14000)
  console.log(s.name, s.age, s.price)

</script>
</body>
</html>

八.组合继承

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>03_组合继承</title>
</head>
<body>
<!--
方式3: 原型链+借用构造函数的组合继承
1. 利用原型链实现对父类型对象的方法继承
2. 利用super()借用父类型构建函数初始化相同属性
-->
<script type="text/javascript">
  function Person(name, age) {
    this.name = name
    this.age = age
  }
  Person.prototype.setName = function (name) {
    this.name = name
  }

  function Student(name, age, price) {
    Person.call(this, name, age)  // 为了得到属性
    this.price = price
  }
  Student.prototype = new Person() // 为了能看到父类型的方法
  Student.prototype.constructor = Student //修正constructor属性
  Student.prototype.setPrice = function (price) {
    this.price = price
  }

  var s = new Student('Tom', 24, 15000)
  s.setName('Bob')
  s.setPrice(16000)
  console.log(s.name, s.age, s.price)

</script>
</body>
</html>

九.进程与线程

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_进程与线程</title>
</head>
<body>
<!--
1. 进程：程序的一次执行, 它占有一片独有的内存空间
2. 线程： CPU的基本调度单位, 是程序执行的一个完整流程
3. 进程与线程
  * 一个进程中一般至少有一个运行的线程: 主线程
  * 一个进程中也可以同时运行多个线程, 我们会说程序是多线程运行的
  * 一个进程内的数据可以供其中的多个线程直接共享
  * 多个进程之间的数据是不能直接共享的
4. 浏览器运行是单进程还是多进程?
  * 有的是单进程
    * firefox
    * 老版IE
  * 有的是多进程
    * chrome
    * 新版IE
5. 如何查看浏览器是否是多进程运行的呢?
  * 任务管理器==>进程
6. 浏览器运行是单线程还是多线程?
  * 都是多线程运行的
-->
</body>
</html>

十.浏览器内核

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_浏览器内核</title>
</head>
<body>
<!--
1. 什么是浏览器内核?
  * 支持浏览器运行的最核心的程序
2. 不同的浏览器可能不太一样
  * Chrome, Safari: webkit
  * firefox: Gecko
  * IE: Trident
  * 360,搜狗等国内浏览器: Trident + webkit
3. 内核由很多模块组成
  * html,css文档解析模块 : 负责页面文本的解析
  * dom/css模块 : 负责dom/css在内存中的相关处理
  * 布局和渲染模块 : 负责页面的布局和效果的绘制
  * 布局和渲染模块 : 负责页面的布局和效果的绘制

  * 定时器模块 : 负责定时器的管理
  * 网络请求模块 : 负责服务器请求(常规/Ajax)
  * 事件响应模块 : 负责事件的管理
-->
</body>
</html>

十一.定时器引发的思考

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>03_定时器引发的思考</title>
</head>
<body>

<button id="btn">启动定时器</button>

<!--
1. 定时器真是定时执行的吗?
  * 定时器并不能保证真正定时执行
  * 一般会延迟一丁点(可以接受), 也有可能延迟很长时间(不能接受)
2. 定时器回调函数是在分线程执行的吗?
  * 在主线程执行的, js是单线程的
3. 定时器是如何实现的?
  * 事件循环模型(后面讲)
-->
<script type="text/javascript">

  document.getElementById('btn').onclick = function () {
    var start = Date.now()
    console.log('启动定时器前...')
    setTimeout(function () {
      console.log('定时器执行了', Date.now()-start)
    }, 200)
    console.log('启动定时器后...')

    // 做一个长时间的工作
    for (var i = 0; i < 1000000000; i++) {

    }
  }
</script>
</body>
</html>

十二.JS是单线程的

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>04_JS是单线程的</title>
</head>
<body>
<!--
1. 如何证明js执行是单线程的?
  * setTimeout()的回调函数是在主线程执行的
  * 定时器回调函数只有在运行栈中的代码全部执行完后才有可能执行
2. 为什么js要用单线程模式, 而不用多线程模式?
  * JavaScript的单线程，与它的用途有关。
  * 作为浏览器脚本语言，JavaScript的主要用途是与用户互动，以及操作DOM。
  * 这决定了它只能是单线程，否则会带来很复杂的同步问题

3. 代码的分类:
  * 初始化代码
  * 回调代码
4. js引擎执行代码的基本流程
  * 先执行初始化代码: 包含一些特别的代码   回调函数(异步执行)
    * 设置定时器
    * 绑定事件监听
    * 发送ajax请求
  * 后面在某个时刻才会执行回调代码
-->
<script type="text/javascript">
  setTimeout(function () {
    console.log('timeout 2222')
    alert('22222222')
  }, 2000)
  setTimeout(function () {
    console.log('timeout 1111')
    alert('1111111')
  }, 1000)
  setTimeout(function () {
    console.log('timeout() 00000')
  }, 0)
  function fn() {
    console.log('fn()')
  }
  fn()

  console.log('alert()之前')
  alert('------') //暂停当前主线程的执行, 同时暂停计时, 点击确定后, 恢复程序执行和计时
  console.log('alert()之后')
</script>
</body>
</html>

十三.web_workers测试

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>06_Web Workers_测试</title>
</head>
<body>
<!--
1. H5规范提供了js分线程的实现, 取名为: Web Workers
2. 相关API
  * Worker: 构造函数, 加载分线程执行的js文件
  * Worker.prototype.onmessage: 用于接收另一个线程的回调函数
  * Worker.prototype.postMessage: 向另一个线程发送消息
3. 不足
  * worker内代码不能操作DOM(更新UI)
  * 不能跨域加载JS
  * 不是每个浏览器都支持这个新特性
-->

<input type="text" placeholder="数值" id="number">
<button id="btn">计算</button>
<script type="text/javascript">
  // 1 1 2 3 5 8    f(n) = f(n-1) + f(n-2)
  function fibonacci(n) {
    return n<=2 ? 1 : fibonacci(n-1) + fibonacci(n-2)  //递归调用
  }
  // console.log(fibonacci(7))
  var input = document.getElementById('number')
  document.getElementById('btn').onclick = function () {
    var number = input.value
    var result = fibonacci(number)
    alert(result)
  }

</script>
</body>
</html>

十四.web_workers测试2

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>06_Web Workers_测试</title>
</head>
<body>
<!--
1. H5规范提供了js分线程的实现, 取名为: Web Workers
2. 相关API
  * Worker: 构造函数, 加载分线程执行的js文件
  * Worker.prototype.onmessage: 用于接收另一个线程的回调函数
  * Worker.prototype.postMessage: 向另一个线程发送消息
3. 不足
  * worker内代码不能操作DOM(更新UI)
  * 不能跨域加载JS
  * 不是每个浏览器都支持这个新特性
-->

<input type="text" placeholder="数值" id="number">
<button id="btn">计算</button>
<script type="text/javascript">
  var input = document.getElementById('number')
  document.getElementById('btn').onclick = function () {
    var number = input.value

    //创建一个Worker对象
    var worker = new Worker('worker.js')
    // 绑定接收消息的监听
    worker.onmessage = function (event) {
      console.log('主线程接收分线程返回的数据: '+event.data)
      alert(event.data)
    }

    // 向分线程发送消息
    worker.postMessage(number)
    console.log('主线程向分线程发送数据: '+number)
  }
  // console.log(this) // window

</script>
</body>
</html>

十五.worker.js

function fibonacci(n) {
  return n<=2 ? 1 : fibonacci(n-1) + fibonacci(n-2)  //递归调用
}

console.log(this)
this.onmessage = function (event) {
  var number = event.data
  console.log('分线程接收到主线程发送的数据: '+number)
  //计算
  var result = fibonacci(number)
  postMessage(result)
  console.log('分线程向主线程返回数据: '+result)
  // alert(result)  alert是window的方法, 在分线程不能调用
  // 分线程中的全局对象不再是window, 所以在分线程中不可能更新界面
}

十六.分号问题

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>01_分号问题</title>
</head>
<body>

<!--
1. js一条语句的后面可以不加分号
2. 是否加分号是编码风格问题, 没有应该不应该，只有你自己喜欢不喜欢
3. 在下面2种情况下不加分号会有问题
  * 小括号开头的前一条语句
  * 中方括号开头的前一条语句
4. 解决办法: 在行首加分号
5. 强有力的例子: vue.js库
6. 知乎热议: https://www.zhihu.com/question/20298345
-->
<script type="text/javascript">
  var a = 3
  ;(function () {

  })()
  /*
   错误理解
   var a = 3(function () {

   })();
  */

  var b = 4
  ;[1, 3].forEach(function () {

  })
  /*
  错误理解
   var b = 4[3].forEach(function () {

   })
   */

</script>
</body>
</html>

十七.设置

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Title</title>
</head>
<body>
<script type="text/javascript">
  console.log(3)
  
  var arr = [1, 3]
  for (var i = 0; i < arr.length; i++) {
    var item = arr[i]
  }

  var fn = function test () {

  }
</script>
</body>
</html>

十八.内存溢出与内存泄漏

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>02_内存溢出与内存泄露</title>
</head>
<body>

<!--
1. 内存溢出
  * 一种程序运行出现的错误
  * 当程序运行需要的内存超过了剩余的内存时, 就出抛出内存溢出的错误
2. 内存泄露
  * 占用的内存没有及时释放
  * 内存泄露积累多了就容易导致内存溢出
  * 常见的内存泄露:
    * 意外的全局变量
    * 没有及时清理的计时器或回调函数
    * 闭包
-->

<script type="text/javascript">
  // 1. 内存溢出
  var obj = {}
  for (var i = 0; i < 10000; i++) {
    obj[i] = new Array(10000000)
    console.log('-----')
  }

  // 2. 内存泄露
    // 意外的全局变量
  function fn() {
    a = new Array(10000000)
    console.log(a)
  }
  fn()

   // 没有及时清理的计时器或回调函数
  var intervalId = setInterval(function () { //启动循环定时器后不清理
    console.log('----')
  }, 1000)

  // clearInterval(intervalId)

    // 闭包
  function fn1() {
    var a = 4
    function fn2() {
      console.log(++a)
    }
    return fn2
  }
  var f = fn1()
  f()

  // f = null

</script>
</body>
</html>
彭于晏爱编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS进阶知识——（四）线程机制与事件机制
js_bbasic的博客
11-21 323
简单水一水
JavaScript第三天
weixin_46291380的博客
01-01 240
自学
JS的事件监听
Raccon_的博客
12-13 3375
事件 鼠标事件 1.onclick 鼠标点击左键触发 2.onmouseover 鼠标经过触发 3.onmouseout 鼠标离开触发 4.onmousemove 鼠标移动触发 5.onmouseup 鼠标弹起触发 6.onmousedown 鼠标按下触发 7.onfocus 获得鼠标焦点触发 8.onblur 失去焦点触发 注册事件 1.传统方式on开头的事件 element.οnclick=function(){} 注：注册事件有唯一性 同一个元素同一个事件只能设置一个处理函数，最后
JavaScript实现异步的4种方法
cherish_20的专栏
09-23 799
你可能知道，Javascript语言的执行环境是”单线程“（single thread）。 所谓”单线程”，就是指一次只能完成一件任务。如果有多个任务，就必须排队，前面一个任务完成，再执行后面一个任务，以此类推。 这种模式的好处是实现起来比较简单，执行环境相对单纯；坏处是只要有一个任务耗时很长，后面的任务都必须排队等着，会拖延整个程序的执行。常见的浏览器无响应（假死），往往就是因为某一段J
DOM的解析渲染流程
ailu5435的博客
05-15 216
一、大致分为五步： 　　1.解析HTML 　　2.构建DOM树 　　3.DOM树与CSS样式进行附着构造呈现树 　　4.布局 　　5.绘制 二、解析渲染过程 　　1.DOM Tree：浏览器将HTML解析成树形的数据结构。 　　2.CSS Rule Tree：浏览器将CSS解析成树形的数据结构。 　　3.Render Tree: DOM和CSSOM合并后生成Render...
js---线程机制
bidepanm的博客
04-20 380
一、进程与线程 进程： 程序的一次运行，它占有一片独立的内存空间 可以通过windows任务管理器查看进程 线程： 是进程内的一个独立执行单元 是程序执行的一个完整流程 是CPU的最小的调度单元 应用程序必须运行在某个进程的某个线程上 一个进程中至少有一个运行的线程：主线程，程序启动后自动创建 一个进程中也可以同时运行多个线程，我们会说程序是多线程运行的 一个进程内的数据可以供其中的多个线程直接共享 多个进程之间的数据是不能直接共享的 线程池（thread pool）：保存多个线程对象的容器，实现
javascript第二天
qq_41943654的博客
03-29 233
javascript第二天 +(正号)数据 可以把其他类型转换为数据类型 1.代码练习 2.运行结果 常见错误 1.运行结果 代码 错误分析： 变量没有声明 2.运行结果 代码 错误分析： 变量多次声明 3.运行结果 代码 错误分析： 缺少括号 ...
第三方JavaScript编程
07-22
资源名称：第三方JavaScript编程内容简介：第三方Javaｓｃｒｉｐｔ应用程序是自包含的应用组件，通常都是小脚本或插件，能够为Web站点增加功能。它们往往是由独立的组织或个人提供的，代码和文件都是来自于远程的Web...
JavaScript基础第04天笔记1
08-03
例如，`arrStus[1]`将返回数组中的第二个元素（在JavaScript中是第三个位置）。 3. **遍历数组** - 常用的遍历方法是使用`for`循环。例如： ```javascript var arr = ['red', 'green', 'blue']; for (var i = 0...
JavaScript高级第03天笔记1
08-04
call、apply 和 bind 三者的异同： * 共同点：都可以改变 this 指向 * 不同点：call 和 apply 会调用函数，并且改变函数内部 this 指向；bind 不会调用函数，仅仅改变函数内部 this 指向。 3. 严格模式 ...
javascript 第三版
05-24
javascript 高级程序设计 第三版
javascript第一课
10-31
在"JavaScript第一课"中，我们将初步了解JavaScript的基础知识，主要涵盖三个方面：如何在网页中插入JavaScript、JavaScript的数据类型以及JavaScript的三个基本对话框。首先，让我们详细探讨如何在HTML页面中添加...
11_javascript线程机制与事件机制
一点江山
10-09 178
进程与线程 进程： 程序的一次执行, 它占有一片独有的内存空间 可以通过windows任务管理器查看进程 线程： 是进程内的一个独立执行单元 是程序执行的一个完整流程 是CPU的最小的调度单元 进程与线程 * 一个进程中一般至少有一个运行的线程: 主线程 * 一个进程中也可以同时运行多个线程, 我们会说程序是多线程运行的 * 一个进程内的数据可以供其中的多个线程直接共享 * 多个进程之间的数...
浅谈js运行机制(线程）
热门推荐
逆风飞舞2016的博客
12-19 2万+
浅谈js运行机制(线程）
JavaScript线程机制与事件机制
weixin_34375233的博客
10-11 90
一、进程与线程 1.进程 进程是指程序的一次执行,它占有一片独有的内存空间,可以通过windows任务管理器查看进程(如下图)。同一个时间里，同一个计算机系统中允许两个或两个以上的进程处于并行状态，这是多进程。比如电脑同时运行微信，QQ，以及各种浏览器等。浏览器运行是有些是单进程，如firefox和老版IE，有些是多进程，如chrome和新版IE。 2.线程 有些进程还不止同时干一件事，比如W...
js线程机制
jgwei的专栏
11-24 4311
前几日写了一篇文章，介绍了js阻塞页面加载的问题。当时是通过例子来验证的。今天，我介绍一下浏览器内核，从原理上介绍一下js阻塞页面加载的原因。 浏览器的内核是多线程的，它们在内核制控下相互配合以保持同步，一个浏览器至少实现三个常驻线程：javascript引擎线程，GUI渲染线程，浏览器事件触发线程。 1.        javascript引擎是基于事件驱动单线程执行的，JS引擎
JS 线程机制与事件机制
05-25 499
一、进程与线程 1. 进程 程序的一次执行，它占有一片独有的内存空间 可以通过windows任务管理器查看进程 可以看出每个程序的内存空间是相互独立的。 2. 线程 概念： 是进程内的一个独立执行单元 是程序执行的一个完整流程 是CPU的最小的调度单元 3.进程与线程 应用程序必须运行在某个进程的某个线程的上 一个进程中至少有一个运行的线程：主线程 --> 进程启动后自动创建 一个进程中也可以同时运行多个线程：此时我们会说这个程序是多线程运行的 过个进程之间的数据是不能直接共享的 -
LibreOffice的国内镜像安装地址和node.js国内快速下载网站
最新发布
小丁的博客
07-08 293
国内镜像包网址：https://mirrors.cloud.tencent.com/libreoffice/libreoffice/
javascript 获取三个月前的月初第一天
07-12
要获取三个月前的月初第一天，可以使用 JavaScript 的 Date 对象和相关方法来完成。下面是一个示例代码： ```javascript // 获取当前日期 var currentDate = new Date(); // 获取当前月份 var currentMonth = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值