简单谈谈javascript Date类型

2024-09-28 04:57:01

1 创建一个新的日期对象，如果不带参数，则对象自动获得当前的日期和时间

var d = new Date()

2 如果需要指定特定的日期，则可以通过Date.parse() 或者 Date().UTC(),返回时间戳作为 new Date()的参数

Date.parse() 用法：

var time = Date.parse('2015/05/20');
var newDate = new Date(time);//Wed May 20 2015 00:00:00 GMT+0800 (中国标准时间)
//转换为格林威治时间
newDate.toUTCString(); //Tue, 19 May 2015 16:00:00 GMT

也可以直接 new Date('2015/05/20') 指定日期，new Date() 构造函数会自动调用 Date.parse()静态方法。

Date.UTC()

Date.UTC()的参数分别是年，月（从0到11），日（1-31），时（0-23），分（0-59），秒（0-59），毫秒（0-999），最少参数2个，即应该包含年月，其他不填的默认为0。

如果要创建的时间为中国标准时间的2015年5月20日,则代码应表示为

var myDate = new Date(Date.UTC(2015,5,19,16,0,0)) //Sat Jun 20 2015 00:00:00 GMT+0800
//格林威治时间
myDate.toUTCString() // Fri, 19 Jun 2015 16:00:00 GMT

其他：

var d = new Date();
//年
d.getFullYear()
//月
d.getMonth()
//日
d.getDate()

下面我们通过具体的示例来看看

/**
 * 日期时间脚本库方法列表：
 * （1）Date.isValiDate：日期合法性验证
 * （2）Date.isValiTime：时间合法性验证
 * （3）Date.isValiDateTime：日期和时间合法性验证
 * （4）Date.prototype.isLeapYear：判断是否闰年
 * （5）Date.prototype.format：日期格式化
 * （6）Date.stringToDate：字符串转成日期类型
 * （7）Date.daysBetween：计算两个日期的天数差
 * （8）Date.prototype.dateAdd：日期计算，支持正负数
 * （9）Date.prototype.dateDiff：比较日期差：比较两个时期相同的字段，返回相差值
 * （10）Date.prototype.toArray：把日期分割成数组：按数组序号分别为：年月日时分秒
 * （11）Date.prototype.datePart：取得日期数据信息
 */ 

/**
 * 日期合法性验证：判断dataStr是否符合formatStr指定的日期格式
 * 示例：
 * （1）alert(Date.isValiDate('2008-02-29','yyyy-MM-dd'));//true
 * （2）alert(Date.isValiDate('aaaa-58-29','yyyy-MM-dd'));//false
 * dateStr：必选，日期字符串
 * formatStr：可选，格式字符串，可选格式有：(1)yyyy-MM-dd(默认格式)或YYYY-MM-DD (2)yyyy/MM/dd或YYYY/MM/DD (3)MM-dd-yyyy或MM-DD-YYYY (4)MM/dd/yyyy或MM/DD/YYYY
 */
Date.isValiDate = function(dateStr, formatStr)
{
  if(!dateStr){
    return false;
  }
  if(!formatStr){
    formatStr = "yyyy-MM-dd";//默认格式：yyyy-MM-dd
  }
  if(dateStr.length!=formatStr.length){
    return false;
  }else{
    if(formatStr=="yyyy-MM-dd"||formatStr=="YYYY-MM-DD"){
      var r1=/^(((((([02468][048])|([13579][26]))(00))|(\d{2}(([02468][48])|([13579][26]))))\-((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-([0-2][0-9]))))|(\d{2}(([02468][1235679])|([13579][01345789]))\-((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-(([0-1][0-9])|(2[0-8]))))))$/;
      return r1.test(dateStr);
    }else if(formatStr=="yyyy/MM/dd"||formatStr=="YYYY/MM/DD"){
      var r2=/^(((((([02468][048])|([13579][26]))(00))|(\d{2}(([02468][48])|([13579][26]))))\/((((0[13578])|(1[02]))\/(([0-2][0-9])|(3[01])))|(((0[469])|(11))\/(([0-2][0-9])|(30)))|(02\/([0-2][0-9]))))|(\d{2}(([02468][1235679])|([13579][01345789]))\/((((0[13578])|(1[02]))\/(([0-2][0-9])|(3[01])))|(((0[469])|(11))\/(([0-2][0-9])|(30)))|(02\/(([0-1][0-9])|(2[0-8]))))))$/;
      return r2.test(dateStr);
    }else if(formatStr=="MM-dd-yyyy"||formatStr=="MM-DD-YYYY"){
      var r3=/^((((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-([0-2][0-9])))\-(((([02468][048])|([13579][26]))(00))|(\d{2}(([02468][48])|([13579][26])))))|(((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-(([0-1][0-9])|(2[0-8])))))\-\d{2}(([02468][1235679])|([13579][01345789])))$/;
      return r3.test(dateStr);
    }else if(formatStr=="MM/dd/yyyy"||formatStr=="MM/DD/YYYY"){
      var r4=/^((((((0[13578])|(1[02]))\/(([0-2][0-9])|(3[01])))|(((0[469])|(11))\/(([0-2][0-9])|(30)))|(02\/([0-2][0-9])))\/(((([02468][048])|([13579][26]))(00))|(\d{2}(([02468][48])|([13579][26])))))|(((((0[13578])|(1[02]))\/(([0-2][0-9])|(3[01])))|(((0[469])|(11))\/(([0-2][0-9])|(30)))|(02\/(([0-1][0-9])|(2[0-8])))))\/\d{2}(([02468][1235679])|([13579][01345789])))$/;
      return r4.test(dateStr);
    }else{
      alert("日期格式不正确！");
      return false;
    }
  }
  return false;
} 

/**
 * 时间合法性验证：判断timeStr是否符合formatStr指定的时间格式
 * 示例：
 * （1）alert(Date.isValiTime('23:59:59','hh:mm:ss'));//true
 * （2）alert(Date.isValiTime('24-68-89','hh:mm:ss'));//false
 * timeStr：必选，日期字符串
 * formatStr：可选，格式字符串，可选格式有：(1)hh:mm:ss(默认格式) (2)hh-mm-ss (3)hh/mm/ss
 */
Date.isValiTime = function(timeStr, formatStr)
{
  if(!timeStr){
    return false;
  }
  if(!formatStr){
    formatStr = "hh:mm:ss";//默认格式：hh:mm:ss
  }
  if(timeStr.length!=formatStr.length){
    return false;
  }else{
    if(formatStr=="hh:mm:ss"){
      var r1=/^(([0-1][0-9])|(2[0-3]))\:([0-5][0-9])\:([0-5][0-9])$/;
      return r1.test(timeStr);
    }else if(formatStr=="hh-mm-ss"){
      var r2=/^(([0-1][0-9])|(2[0-3]))\-([0-5][0-9])\-([0-5][0-9])$/;
      return r2.test(timeStr);
    }else if(formatStr=="hh/mm/ss"){
      var r3=/^(([0-1][0-9])|(2[0-3]))\/([0-5][0-9])\/([0-5][0-9])$/;
      return r3.test(timeStr);
    }else{
      alert("时间格式不正确！");
      return false;
    }
  }
  return false;
} 

/**
 * 日期和时间合法性验证
 * 格式：yyyy-MM-dd hh:mm:ss
 */
Date.isValiDateTime = function(dateTimeStr)
{
  var dateTimeReg=/^(((((([02468][048])|([13579][26]))(00))|(\d{2}(([02468][48])|([13579][26]))))\-((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-([0-2][0-9]))))|(\d{2}(([02468][1235679])|([13579][01345789]))\-((((0[13578])|(1[02]))\-(([0-2][0-9])|(3[01])))|(((0[469])|(11))\-(([0-2][0-9])|(30)))|(02\-(([0-1][0-9])|(2[0-8]))))))(\s{1}(([0-1][0-9])|(2[0-3]))\:([0-5][0-9])\:([0-5][0-9]))?$/
  return dateTimeReg.test(dateTimeStr);
} 

/**
 * 判断闰年 ：一般规律为：四年一闰，百年不闰，四百年再闰。
 */
Date.prototype.isLeapYear = function()
{
  return (this.getYear()%4==0&&((this.getYear()%100!=0)||(this.getYear()%400==0)));
} 

/**
 * 日期格式化：
 * formatStr：可选，格式字符串，默认格式：yyyy-MM-dd hh:mm:ss
 * 约定如下格式：
 * （1）YYYY/yyyy/YY/yy 表示年份
 * （2）MM/M 月份
 * （3）W/w 星期
 * （4）dd/DD/d/D 日期
 * （5）hh/HH/h/H 时间
 * （6）mm/m 分钟
 * （7）ss/SS/s/S 秒
 * （8）iii 毫秒
 */
Date.prototype.format = function(formatStr)
{
  var str = formatStr;
  if(!formatStr){
    str = "yyyy-MM-dd hh:mm:ss";//默认格式
  }
  var Week = ['日','一','二','三','四','五','六']; 

  str=str.replace(/yyyy|YYYY/,this.getFullYear());
  str=str.replace(/yy|YY/,(this.getYear() % 100)>9?(this.getYear() % 100).toString():'0' + (this.getYear() % 100)); 

  str=str.replace(/MM/,this.getMonth()>=9?(parseInt(this.getMonth())+1).toString():'0' + (parseInt(this.getMonth())+1));
  str=str.replace(/M/g,(parseInt(this.getMonth())+1)); 

  str=str.replace(/w|W/g,Week[this.getDay()]); 

  str=str.replace(/dd|DD/,this.getDate()>9?this.getDate().toString():'0' + this.getDate());
  str=str.replace(/d|D/g,this.getDate()); 

  str=str.replace(/hh|HH/,this.getHours()>9?this.getHours().toString():'0' + this.getHours());
  str=str.replace(/h|H/g,this.getHours());
  str=str.replace(/mm/,this.getMinutes()>9?this.getMinutes().toString():'0' + this.getMinutes());
  str=str.replace(/m/g,this.getMinutes()); 

  str=str.replace(/ss|SS/,this.getSeconds()>9?this.getSeconds().toString():'0' + this.getSeconds());
  str=str.replace(/s|S/g,this.getSeconds()); 

  str=str.replace(/iii/g,this.getMilliseconds()<10?'00'+this.getMilliseconds():(this.getMilliseconds()<100?'0'+this.getMilliseconds():this.getMilliseconds())); 

  return str;
} 

/**
 * 字符串转成日期类型：
 * dateStr：必选，日期字符串，如果无法解析成日期类型，返回null
 * 格式：
 * （1）yyyy/MM/dd：IE和FF通用
 * （2）MM/dd/yyyy：IE和FF通用
 * （3）MM-dd-yyyy：仅IE
 * （4）yyyy-MM-dd：非IE，且时钟被解析在8点整
 */
Date.stringToDate = function(dateStr)
{
  if(!dateStr){
    alert("字符串无法解析为日期");
    return null;
  }else{
    if(Date.isValiDate(dateStr,"yyyy/MM/dd")||Date.isValiDate(dateStr,"MM/dd/yyyy")){
      return new Date(Date.parse(dateStr));
    }else{
      if((!-[1,])){//IE
        if(Date.isValiDate(dateStr,"MM-dd-yyyy")){
          return new Date(Date.parse(dateStr));
        }else{
          alert("字符串无法解析为日期");
          return null;
        }
      }else{//非IE
        if(Date.isValiDate(dateStr,"yyyy-MM-dd")){
          return new Date(Date.parse(dateStr));
        }else{
          alert("字符串无法解析为日期");
          return null;
        }
      }
    }
  }
  return null;
} 

/**
 * 计算两个日期的天数差：
 * dateOne：必选，必须是Data类型的实例
 * dateTwo：必选，必须是Data类型的实例
 */
Date.daysBetween = function(dateOne,dateTwo)
{
  if((dateOne instanceof Date)==false||(dateTwo instanceof Date)==false){
    return 0;
  }else{
    return Math.abs(Math.floor((dateOne.getTime()-dateTwo.getTime())/1000/60/60/24));
  }
} 

/**
 * 日期计算：支持负数，即可加可减，返回计算后的日期
 * num：必选，必须是数字，且正数是时期加，负数是日期减
 * field：可选，标识是在哪个字段上进行相加或相减，字段见如下的约定。无此参数时，默认为d
 * 约定如下格式：
 * （1）Y/y 年
 * （2）M 月
 * （3）W/w 周
 * （4）D/d 日
 * （5）H/h 时
 * （6）m 分
 * （7）S/s 秒
 * （8）Q/q 季
 */
Date.prototype.dateAdd = function(num, field)
{
  if((!num)||isNaN(num)||parseInt(num)==0){
    return this;
  }
  if(!field){
    field = "d";
  }
  switch(field){
    case 'Y':
    case 'y':return new Date((this.getFullYear()+num), this.getMonth(), this.getDate(), this.getHours(), this.getMinutes(), this.getSeconds());break;
    case 'Q':
    case 'q':return new Date(this.getFullYear(), (this.getMonth()+num*3), this.getDate(), this.getHours(), this.getMinutes(), this.getSeconds());break;
    case 'M':return new Date(this.getFullYear(), this.getMonth()+num, this.getDate(), this.getHours(), this.getMinutes(), this.getSeconds());break;
    case 'W':
    case 'w':return new Date(Date.parse(this) + ((86400000 * 7) * num));break;
    case 'D':
    case 'd':return new Date(Date.parse(this) + (86400000 * num));break;
    case 'H':
    case 'h':return new Date(Date.parse(this) + (3600000 * num));break;
    case 'm':return new Date(Date.parse(this) + (60000 * num));break;
    case 'S':
    case 's':return new Date(Date.parse(this) + (1000 * num));break;
    default: return this;
  }
  return this;
} 

/**
 * 比较日期差：比较两个时期相同的字段，返回相差值
 * dtEnd：必选，必须是Data类型的实例
 * field：可选，标识是在哪个字段上进行比较，字段见如下的约定。无此参数时，默认为d
 * 约定如下格式：
 * （1）Y/y 年
 * （2）M 月
 * （3）W/w 周
 * （4）D/d 日
 * （5）H/h 时
 * （6）m 分
 * （7）S/s 秒
 */
Date.prototype.dateDiff = function(dtEnd, field)
{
  var dtStart = this;
  if((dtEnd instanceof Date)==false){
    return 0;
  }else{
    if(!field){
      field = "d";
    }
    switch(field){
      case 'Y':
      case 'y':return dtEnd.getFullYear() - dtStart.getFullYear();break;
      case 'M':return (dtEnd.getMonth()+1)+((dtEnd.getFullYear()-dtStart.getFullYear())*12) - (dtStart.getMonth()+1);break;
      case 'W':
      case 'w':return parseInt((dtEnd - dtStart) / (86400000 * 7));break;
      case 'D':
      case 'd':return parseInt((dtEnd - dtStart) / 86400000);break;
      case 'H':
      case 'h':return parseInt((dtEnd - dtStart) / 3600000);break;
      case 'm':return parseInt((dtEnd - dtStart) / 60000);break;
      case 'S':
      case 's':return parseInt((dtEnd - dtStart) / 1000);break;
      default: return 0;
    }
    return 0;
  }
} 

/**
 * 把日期分割成数组：按数组序号分别为：年月日时分秒
 */
Date.prototype.toArray = function()
{
  var myArray = new Array();
  myArray[0] = this.getFullYear();
  myArray[1] = this.getMonth();
  myArray[2] = this.getDate();
  myArray[3] = this.getHours();
  myArray[4] = this.getMinutes();
  myArray[5] = this.getSeconds();
  return myArray;
} 

/**
 * 取得日期数据信息：
 * field：可选，标识是在哪个字段上进行比较，字段见如下的约定。无此参数时，默认为d
 * （1）Y/y 年
 * （2）M 月
 * （3）W/w 周
 * （4）D/d 日
 * （5）H/h 时
 * （6）m 分
 * （7）S/s 秒
 */
Date.prototype.datePart = function(field)
{
  if(!field){
    field = "d";
  }
  var Week = ['日','一','二','三','四','五','六'];
  switch (field){
    case 'Y' :
    case 'y' :return this.getFullYear();break;
    case 'M' :return (this.getMonth()+1);break;
    case 'W' :
    case 'w' :return Week[this.getDay()];break;
    case 'D' :
    case 'd' :return this.getDate();break;
    case 'H' :
    case 'h' :return this.getHours();break;
    case 'm' :return this.getMinutes();break;
    case 's' :return this.getSeconds();break;
    default:return this.getDate();
  }
  return this.getDate();
}

javascript引用类型之时间Date和数组Array

Javascript引用类型之时间Date JavaScript中的Date类型是在早期Java中的java.util.Date类基础上构建的.为此,Date类型使用自UTC 1970年1月1日零时开始经过的毫秒数来保存日期.在使用这种数据存储格式的条件下,Date类型保存的日期能够精确到1970年1月1日之前或之后的285 616年. 创建日期对象在javascript中,可以使用Date()构造函数来创建日期对象,如: 复制代码代码如下: var date=new Date(); 当没有
js表格排序实例分析（支持int,float,date,string四种数据类型）

本文实例讲述了js表格排序的方法.分享给大家供大家参考.具体如下: <html> <head> <title>SortTable2</title> <meta http-equiv="content-type" content="text/html; charset=UTF-8"> <script type="text/javascript"> var k=0; /**//*
Javascript中Date类型和Math类型详解

Date类型 ECMASCript中的Date类型是在早期中Java中的java.util.Date类基础上构建的.为此Date类型使用自UTC(国际协调时间)1970年1月1日午夜(0时)开始经过的毫秒数来保存日期. 创建日期对象 1.创建当前日期.不需要传入参数 2.创建指定日期.需要传入参数,必须传入表示该日期的毫秒数(即从1970年1月1日午夜起至该日期止经过的毫秒数).为了简化这一计算过程,ECMAScript提供了两个方法:Date.parse()和Date.UTC(). var n
让python json encode datetime类型

实现代码如下: 复制代码代码如下: import json from datetime import date, datetime def __default(obj): if isinstance(obj, datetime): return obj.strftime('%Y-%m-%dT%H:%M:%S') elif isinstance(obj, date): return obj.strftime('%Y-%m-%d') else: raise TypeError('%r is not
javascript学习笔记(六) Date 日期类型

1.创建日期对象复制代码代码如下: var now = new Date(); //获得当前系统日期和时间 var someDate = new Date(Date.parse("May 25,2012")); var someDate = new Date("May 25,2012"); //与上相同 var someDate = new Date(Date.UTC(2010,0)); //GMT时间2010年1月1日凌晨0时 var someDate = n
javascript中对Date类型的常用操作小结

javascript中对Date类型的常用操作小结 /** 3. * 日期时间脚本库方法列表: 4. * (1)Date.isValiDate:日期合法性验证 5. * (2)Date.isValiTime:时间合法性验证 6. * (3)Date.isValiDateTime:日期和时间合法性验证 7. * (4)Date.prototype.isLeapYear:判断是否闰年 8. * (5)Date.prototype.format:日期格式化 9. * (6)Date.stringToD
JavaScript:Date类型全面解析

创建一个日期对象,使用new操作符后跟Date的构造函数. var date = new Date(); 调用默认构造函数情况下,新创建的日期自动获得当前时间和日期.如果需要指定日期和时间,需要传入表示该日期的毫秒数. JavaScript中提供了两个方法来计算日期,Date.parse()方法接收一个表示日期的字符串参数,然后根据这个日期返回相应的日期毫秒数.但是日期的格式往往因实现以及地区而异.Date.UTC()也返回表示日期的毫秒数,它的参数分别是年份.基于0的月份(一月是0).月中的那
简单谈谈javascript Date类型

1 创建一个新的日期对象,如果不带参数,则对象自动获得当前的日期和时间 var d = new Date() 2 如果需要指定特定的日期,则可以通过Date.parse() 或者 Date().UTC(),返回时间戳作为 new Date()的参数 Date.parse() 用法: var time = Date.parse('2015/05/20'); var newDate = new Date(time);//Wed May 20 2015 00:00:00 GMT+0800 (中国标准时
简单谈谈Javascript中类型的判断

数据类型的判断有这么几种方式 1.一元运算符 typeOf 2.关系运算符 instanceof 3.constructor 属性 4.prototype属性一.typeof typeof的返回值有以下几种类型结构 Undefined "undefined" Null "object" (见下方) 布尔值 "boolean" 数值 "number" 字符串 "string" Symbol (ECMAS
简单谈谈javascript高级特性

js中没有class的概念,我们可以使用function来模拟. 惰性载入函数例如我们通常使用以下的js代码创建ajax: function createXHR () { var xhr = null; try{ xhr = new XMLHttpRequest(); // FF.Opera.Safari.IE7 } catch(e) { handlerError(e); try{ xhr = new ActiveXObject('Msxml2.XMLHTTP'); } catch (e) {
简单谈谈Javascript函数中的arguments

一.arguments的面貌在javascript中所有的函数内部都包含了一个隐藏的变量叫arguments;它存放着所有传递到这个函数中的参数: 那么我们打开实例看看arguments的输出形式 (function fn(){ console.log(arguments) })(1,2,3,4) 结果好像是类似数组的形式打印在控制台,相信大多数人包括我看到这种输出就会认为arguments是一个数组,那么既然是数组就可以用数组的一些方法了吧,再看下一个例子: (function fn(){
简单谈谈javascript中的变量、作用域和内存问题

[变量] [1]定义:可变的量,相当于给一个不定的数据起了一个外号.变量是存储信息的容器. [2]特性:js中的变量是松散类型的,可以保存任何类型的数据.它只是在特定时间用于保存特定值的一个名字而已.由于不存在定义某个变量必须要保存何种数据类型值的规则,变量的值及其数据类型可以在脚本的生命周期内改变. [3]变量声明:变量可以在声明时赋值,但不能有其他操作,如+=.-=等 var a = 2;//是正确的 var a += 2;//是错误的 var a = 2++;//是错误的,++只能用于变量
简单谈谈JavaScript寄生式组合继承

组合继承组合继承也被称为伪经典继承,它综合了我们昨天说的原型链和盗用构造函数,将俩者的有点结合在了一起.它的基本思想是使用原型链继承原型上的属性和方法,通过盗用构造函数继承实例属性,这样的好处就是可以把方法定义在原型上复用,每个实例又有自己的属性. function SuperType (name) { this.name = name; this.colors = ["red","yellow","bule"]; } SuperType.pr
简单谈谈JavaScript变量提升

目录前言 1. 什么变量提升? 2. 为什么会有变量提升? (1)提高性能 (2)容错性更好 3. 变量提升导致的问题 (1)变量被覆盖 (2)变量没有被销毁 4. 禁用变量提升 5. JS如何支持块级作用域 (1)创建执行上下文 (2)执行代码 6. 暂时性死区总结前言在 ECMAScript6 中,新增了 let 和 const 关键字用来声明变量.在前端面试中也常被问到 let.const和 var 的区别,这就涉及到了变量提升.暂时性死区等知识点.下面就来看看什么是变量提升和暂时
简单谈谈JavaScript的同步与异步

1.手绘一张图说明. 2.为什么JavaScript是单线程(这里引用阮一峰老师的话) JavaScript的单线程,与它的用途有关. 作为浏览器脚本语言,JavaScript的主要用途是与用户互动,以及操作DOM. 这决定了它只能是单线程,否则会带来很复杂的同步问题. 比如,假定JavaScript同时有两个线程,一个线程在某个DOM节点上添加内容,另一个线程删除了这个节点,这时浏览器应该以哪个线程为准? 所以,为了避免复杂性,从一诞生,JavaScript就是单线程,这已经成了这门语言的核心
简单谈谈javascript代码复用模式

代码复用有一个著名的原则,是GoF提出的:优先使用对象组合,而不是类继承.在javascript中,并没有类的概念,所以代码的复用,也并不局限于类式继承.javascript中创建对象的方法很多,有构造函数,可以使用new创建对象,并且可以动态的修改对象.javascript的非类式继承(可称为现代继承模式)复用方法也很多,例如,利用其它对象组合成所需要的对象,对象混入技术,借用和复用所需要的方法. 类式继承模式-默认模式两个构造函数Parent和Child的例子: 复制代码代码如下: fu

简单谈谈javascript Date类型

相关推荐

随机推荐