TypeScript学习—————封装一个获取时间的函数

需求：

1. 该函数可以获取当前时间，返回YYYY-MM-DD HH:ii:ss 格式的时间。

2. 该函数可以获取当前时间，返回YYYY-MM-DD格式的时间。

3. 该函数可以获取当前时间，根据参数返回 年，月，日，时，分，秒，星期相对应的值。

4. 该函数可以获取当前时间（前/后）n年，n月，n日，n时，n分，n秒后对应的时间以及指定时间单位的值。

5. 该函数可以获取传入时间，相对应的以上所有功能。

分析：

• 首先判断函数应有的入参：
  1>.需要获取的时间参照。是以当前时间为参照还是以传入时间为参照。所以由此确定该函数的时间 参数为：defaultData
  2>.需要获取的值是以（传入时间 或 默认当前时间）相对应（之前/之后）的时间。所以（之前/之后）需要由参数形式传入。定为value
  3>.当 value 值传入时，我们需要判断当前要获取的是value （之前/之后）年？月？日？…的时间。所有需要一个时间类型的参数。定为type
  4>.需要返回的 值 的类型。（需要返回什么类型，什么格式的值。例如：我需要该函数返回一个完整的时间点。那么应该返回的值就是 YYYY-MM-DD HH:ii:ss 格式的时间。再例如我想获取当前时间所在年份（2021）的值。那么应该返回的值就是2021）。由此，确定该函数返回“值”的类型的形参定为：params

• 其次分析函数中需要完成的工作：

  1>.判断是以当前时间为主体还是以传入时间为主体。
  2>.判断获取的是相对主体时间之前还是之后多长时间的时间。
  3>.判断value的单位，获取 value 年/月/日… 的时间。
  4>.根据入参要求的返回值类型。返回相对应的值。

• 根据功能划分函数。我暂且划分为2个函数。

具体编码
1.首先封装一个可以根据传入的时间和返回类型返回相应值的函数。如：
let year = 函数名（时间，年）；
我希望得到的是传入时间对应的年份。

//声明一个有两个形参：时间（value:any）和 类型（params:string）的函数。
//params可传递的值有以下几种
//返回当前年：year
//返回当前月：month
//返回当前日：date
//返回当前小时：hours
//返回当前分钟：minutes
//返回当前秒钟：seconds
//返回当前星期：week
//返回当前日期：curryDate
//返回当前时间：curryTime
//返回当前日期时间：curryDateTime
let getMoment = (params:string,value:any):string=>{
	//第一步工作，拿到传入该函数的时间value
	const dateTime:any = value;
	//第二步工作，分别获取传入时间的年，月，日，时，分，秒，星期，YYYY-MM-DD，HH:ii:ss，YYYY-MM-DD HH:ii:ss格式的值
	let year:number = dateTime.getFullYear();//当前年
    let month:any = dateTime.getMonth() + 1;
    let date:any = dateTime.getDate();
    let hours:any = dateTime.getHours();
    let minutes:any = dateTime.getMinutes();
    let seconds:any = dateTime.getSeconds();
    let week:any = dateTime.getDay();
    month = month<10?'0'+month:month;//当前月
    date = date<10?'0'+date:date;//当前日
    hours = hours<10?'0'+hours:hours;//当前小时
    minutes = minutes<10?'0'+minutes:minutes;//当前分钟
    seconds = seconds<10?'0'+seconds:seconds;//当前秒钟
    week == 0?'日':week;//当前星期
    let curryDate:any = year+'-'+month+'-'+date;//当前日期
    let curryTime:any = hours+':'+minutes+':'+seconds;//当前时间
    let curryDateTime:any = year+'-'+month+'-'+date+' '+hours+':'+minutes+':'+seconds;//当前日期时间
    //第三步工作，根据传入类型判断要返回的值，这里为了避免大量if判断。采用了策略模式。
    const paramsList:any = {
      'year': ()=>{return year},
      'month': ()=>{return month},
      'date': ()=>{return date},
      'hours': ()=>{return hours},
      'minutes': ()=>{return minutes},
      'seconds': ()=>{return seconds},
      'week': ()=>{
        let weekArr:any={
          0:()=>{return '日'},
          1:()=>{return '一'},
          2:()=>{return '二'},
          3:()=>{return '三'},
          4:()=>{return '四'},
          5:()=>{return '五'},
          6:()=>{return '六'}
        }
        return weekArr[week] ? weekArr[week]() : 'no';
      },
      'curryDate':()=>{return curryDate},
      'curryTime': ()=>{return curryTime},
      'curryDateTime': ()=>{return curryDateTime},
    }
    return paramsList[params] ? paramsList[params]() : 'no';
}
//到此为止，我们可以传入任意时间并获取到需要的返回的值了。
//例如：
//获取当前时间的年份
let curryYear:string = paramsList('year',new Date());
console.log(curryYear);//2021
//获取当前时间的年月日
let curryDate:string = paramsList('curryDate',new Date());
console.log(curryDate);//2021-02-20

2.第一个函数已经封装完成。我们可以通过传入一个时间和类型得到我们所需要的相对返回类型的值。但是仅仅这样还不够。我们还需要能获取某个时间之前或之后，几天或几年或几个月 的时间 的 年份或月份或时间。所以还需要封装一个函数，在这个函数中我们希望他可以处理前后 n 年/月/日… 以及返回值类型 和 默认时间

//type：获取前后type日期('type':类型(年(year)/月(month)/日(date)/时(hours)/分(minutes)/秒(seconds)) 
//value：获取value的type日期('value<0':前value+type | 'value>0':后value+type)
//params:获取params格式的值（同getMoment()函数的形参params）
//defaultData:默认日期（不传递该参数则默认为当前时间：接收格式为：YYYY-MM-DD 或 YYYY-MM-DD HH:ii:ss）
let filterMoment = (type="default",value=0,params="curryDateTime",defaultData='default'):string=>{
	//判断默认时间是否传递
	let dateTime:any;
    defaultData == 'default'?dateTime = new Date():dateTime = new Date(defaultData);
    //根据type不同类型处理 value + type 的时间。
    const typeArray:any = {
    	//(获取到前/后value年的时间。并传给getMoment函数处理)
        'year':()=>{
            dateTime.setFullYear(dateTime.getFullYear() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //(获取到前/后value月的时间。并传给getMoment函数处理)
        'month':()=>{
            dateTime.setMonth(dateTime.getMonth() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //(获取到前/后value日的时间。并传给getMoment函数处理)
        'date':()=>{
            dateTime.setDate(dateTime.getDate() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //(获取到前/后value小时的时间。并传给getMoment函数处理)
        'hours':()=>{
            dateTime.setHours(dateTime.getHours() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //(获取到前/后value分钟的时间。并传给getMoment函数处理)
        'minutes':()=>{
            dateTime.setMinutes(dateTime.getMinutes() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //(获取到前/后value秒钟的时间。并传给getMoment函数处理)
        'seconds':()=>{
            dateTime.setSeconds(dateTime.getSeconds() + value);
            let curryDate = getMoment(params,dateTime);
            return curryDate            
        },
        //不传递类型，则返回YYYY-MM-DD HH:ii:ss格式的当前时间
        'default':()=>{
            let curryDate = getMoment(params,dateTime);
            return curryDate
        }
    }
    return typeArray[type] ? typeArray[type]() : 'no';
}

//到此，我们已经满足了所有需求。
//获取当前时间，返回YYYY-MM-DD HH:ii:ss 格式
let curryDateTime = filterMoment();
console.log(curryDateTime)//2021-02-20 17:31:33
//获取当前时间，返回YYYY-MM-DD格式
let curryDate = filterMoment(undefined,undefined,'curryDate',undefined);
console.log(curryDateTime)//2021-02-20
//获取当前时间，返回年
let curryYear = filterMoment(undefined,undefined,'year',undefined);
console.log(curryYear)//2021
//获取当前时间前一年，返回年
let curryYear = filterMoment('year',-1,'year',undefined);
console.log(curryYear)//2020
//获取2020年的前一年，返回年
let curryYear = filterMoment('year',-1,'year','2020');
console.log(curryYear)//2019

是不是非常强大~~~~~