前后端、数据库时间格式化方法

简介: 前后端、数据库时间格式化方法

一、前端 moment.js 的常用方法

官网: http://momentjs.cn/

一、引入moment.js

1.Nodejs方式引入

(1)安装

npm install moment _–save _

yarn add moment # Yarn

(2)引入

// require 方式

var moment = require(‘moment’);

// import 方式

import moment from ‘moment’;

2.浏览器方式引入

二、使用

1. 使用moment.js格式化日期

moment().format('MMMM Do YYYY, h:mm:ss a'); // 七月 20日 2022, 4:25:13 下午
moment().format('dddd');                    // 星期三
moment().format("MMM Do YY");               // 7月 20日 22
moment().format('YYYY [escaped] YYYY');     // 2022 escaped 2022
moment().format('YYYY-MM-DD HH:mm:ss')        //"2022-07-20 16:46:40"
moment().format('YYYY年MM月DD日 HH时mm分ss秒') //"2022年07月20日 16时47分17秒"
moment().format('YYYY年MM月DD日 HH:mm:ss')    // "2022年07月20日 16:46:18"
moment().format('YYYY.MM.DD HH:mm:ss')        //"2022.07.20 16:47:58"

2. 相对时间

moment("20111031", "YYYYMMDD").fromNow(); // 11 年前
moment("20120620", "YYYYMMDD").fromNow(); // 10 年前
moment().startOf('day').fromNow();        // 16 小时前
moment().endOf('day').fromNow();          // 8 小时内
moment().startOf('hour').fromNow();       // 25 分钟前

3.获取/设置时间信息

moment().second() //获得 秒
moment().second(Number) //设置 秒。0 到 59
moment().minute() //获得 分
moment().minute(Number) //设置 分。0 到 59
// 类似的用法
moment().hour() // 小时
moment().date() // 一个月里的第几天
moment().day() // 星期几
moment().dayOfYear() // 一年里的第几天
moment().week() // 一年里的第几周
moment().month() // 第几个月
moment().quarter() // 一年里的第几个季度
moment().year() // 年
moment().daysInMonth() // 当前月有多少天

4.操作

moment().add(7, 'days') // 之后的第7天。第2个参数还可以是 'months', 'years' 等。注意是复数。
moment().add(7, 'd')// 与上面一行代码的运行结果一样。
moment().subtract(1, 'months') // 上个月
 
moment().startOf('week') // 这周的第一天
moment().startOf('hour') // 等效与 moment().minutes(0).seconds(0).milliseconds(0)。
// 还支持 'year','month' 等
 
moment().endOf('week')

5.查询

// 早于
moment('2010-10-20').isBefore('2010-10-21') // true
moment('2010-10-20').isBefore('2010-12-31', 'year') // false
moment('2010-10-20').isBefore('2011-01-01', 'year') // true
 
// 是否相等
moment('2010-10-20').isSame('2010-10-20') // true
moment('2010-10-20').isSame('2009-12-31', 'year')  // false
moment('2010-10-20').isSame('2010-01-01', 'year')  // true
 
// 晚于
moment('2010-10-20').isAfter('2010-10-19') // true
moment('2010-10-20').isAfter('2010-01-01', 'year') // false
moment('2010-10-20').isAfter('2009-12-31', 'year') // true
 
// 是否在时间范围内
moment('2010-10-20').isBetween('2010-10-19', '2010-10-25') // true
moment('2010-10-20').isBetween('2010-01-01', '2012-01-01', 'year') // false
moment('2010-10-20').isBetween('2009-12-31', '2012-01-01', 'year') // true
 
moment().isLeapYear() // 是否是闰年

二、mysql 时间函数

1. 获取当前时间

-- 返回当前日期 2022-07-20
select curdate() ; 
-- 返回当前时间 16:46:41
select curtime() ;
-- 返回当前日期和时间 2022-07-20 16:47:02
select now() ;
-- 返回当前日期和时间 20220720164739
select now() + 0 ;
-- 返回日期 date 年份 2022
select year(now())   
-- 返回日期 date 月份  7
select month(now()) ;
-- 返回日期 date 月份的名字 July
select monthname(now()) ;
-- 返回日期 date 为一年中的第几周 29
select week(now()) ;
-- 返回 time 的小时值 16
select hour(now()) ;
-- 返回 time 的小时值
select minute(now()) ;

2.时间变化

-- 在当前时间上增加 3 天 2022-07-23 16:55:21
select date_add(now(), interval 3 day) ;
--  在当前时间上增加 3 天  加上时间格式化 2022-07-23  
 SELECT   DATE_FORMAT( DATE_ADD(NOW(),INTERVAL 3 DAY) ,'%Y-%m-%d') 
-- 9分钟前  加上格式化 2022-07-20 16:52:00
  SELECT   DATE_FORMAT( DATE_ADD(NOW(),INTERVAL-9 MINUTE) ,'%Y-%m-%d %H:%i:00')    
-- 在当前时间上减少 3 天
select date_add(now(), interval -3 day) ; 
-- 在当前时间上增加 1 小时
select date_add(now(), interval 1 hour);  
-- 在当前时间上增加 1 分钟
select date_add(now(), interval 1 minute);  
-- 在当前时间上增加 1 秒
select date_add(now(), interval 1 second); 
-- 在当前时间上增加 1 微秒
select date_add(now(), interval 1 microsecond); 
-- 在当前时间上增加 1 星期
select date_add(now(), interval 1 week); 
-- 在当前时间上增加 1 个月
select date_add(now(), interval 1 month);  
-- 在当前时间上增加 1 个季度,相当于3个月
select date_add(now(), interval 1 quarter);  
-- 在当前时间上增加 1 年
select date_add(now(), interval 1 year); 
//计算两个时间的天数差
select datediff(now()," 2022-07-10")

//结果是:-10 

3.时间格式化

select date_format(now(),"%Y/%m/%d") 
  //  2018/05/10
select date_format(now(),'%Y-%m-%d %H') 
 // 2022-07-20 17



4。
SELECT 
  CASE
  WHEN WEEKDAY(NOW()-INTERVAL DAY(NOW()) DAY) = 6 THEN (DAY(NOW())+WEEKDAY(NOW()-INTERVAL DAY(NOW()) DAY)) DIV 7
  ELSE (DAY(NOW())+WEEKDAY(NOW()-INTERVAL DAY(NOW()) DAY)) DIV 7 + 1
  END week_of_month

Java时间处理

public class TimeUtil {
    private static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
    

      /**
    * 获取当前日期指定天数之后的日期.
    * @param num   相隔天数
    * @return Date 日期
    * @since 1.0
    */
   public static Date nextDay(int num) {
      Calendar curr = Calendar.getInstance();
      curr.set(Calendar.DAY_OF_MONTH, curr.get(Calendar.DAY_OF_MONTH) + num);
      return curr.getTime();
   }
    
 
      /**
     * 获取当前时间的10位时间戳
     * @return
     */
    public static String getTimestamp(){
        return String.valueOf(System.currentTimeMillis() / 1000);
    }

    /**
     * 获取当前时间 按指定格式来 yyyy-MM-dd HH:mm:ss
     * @return
     */
    public  static  String getTime(){
        Date now = new Date();
        String time = sdf.format(now);
        return time;
    }

    /**
     * date转String 按指定格式来 yyyy-MM-dd HH:mm:ss
     * @return
     */
    public  static  String getAttrTime(Date date){
        String time = sdf.format(date);
        return time;
    }

    /**
     * 时间戳转String 按指定格式来 yyyy-MM-dd HH:mm:ss 13位时间戳
     * @return
     */
    public  static  String getLongTime(long stamp){
        String time = sdf.format(new Date(stamp));
        return time;
    }

    /**
     * 时间戳转String 按指定格式来 yyyy-MM-dd HH:mm:ss
     * @return
     */
    public  static  String getAttrLongTime(long stamp){
        long longTime = stamp * 1000;
        String time = sdf.format(new Date(longTime));
        return time;
    }

   
    
    /**
     * 校验时间是否是小于现在时间 处于合理范围内
     * @param createTime 时间
     * @param dayNum 天数
     * @return
     */
    public static boolean checkDateTime(Date createTime,long dayNum){
        Date date1 = new Date();
        if(null==createTime){
            createTime = date1;
        }
        long day=(date1.getTime()-createTime.getTime())/(24*60*60*1000);
        if(day <= dayNum){
            return true;
        }
        return false;
    }

    /**
     * 校验时间 并获取分钟差异的时间
     * @param dateTime 时间
     * @param minuteTime 差异分钟数 -5 5分钟之前的时间
     * @return
     */
    public static String checkVipOrderTimeStamp(String dateTime,Integer minuteTime){
        if(NullUtils.isNullString(dateTime)){
            return getMinuteTimeStamp(minuteTime);
        }else{
            try {
                sdf.parse(dateTime);//检测
            } catch (ParseException e) {
                e.printStackTrace();
                return getMinuteTimeStamp(minuteTime);
            }
        }
        return dateTime;
    }

    /**
     * 获取分钟差异的时间
     * @param minuteTime 差异分钟数 -5 5分钟之前的时间
     * @return
     */
    public static String getMinuteTimeStamp(Integer minuteTime){
        //获取当前时间的前5分钟时间
        Calendar beforeTime = Calendar.getInstance();
        beforeTime.add(Calendar.MINUTE, minuteTime);
        Date date = beforeTime.getTime();
        String time = sdf.format(date);
//        System.out.println(time);
        return time;
    }

    /**
     * 查询唯代购品牌是否满足时间条件 必须大于多少天才能入库
     * @param dateEnd  标准格式 yyyy-MM-dd HH:mm:ss 品牌结束时间
     * @param day 时间 必须大于多少时间
     * @return
     * @throws ParseException
     */
    public static boolean getVdgBrandSellTime(String dateEnd,long day) {
        if(NullUtils.isNullString(dateEnd)){
            return  false;
        }
        try{
            Date d1 = sdf.parse(dateEnd);//转Date
//            Date d2 = sdf.parse(dateStart);//转Date
            Date d2 = new Date();//转Date
            long diff = d1.getTime() - d2.getTime();//这样得到的差值是毫秒级别
            long days = diff / (1000 * 60 * 60 * 24);
//            long hours = (diff-days*(1000 * 60 * 60 * 24))/(1000* 60 * 60);
            long minutes = (diff-days*(1000 * 60 * 60 * 24)-hours*(1000* 60 * 60))/(1000* 60);
//            System.out.println(""+days+"天"+hours+"小时"+minutes+"分");
            if(days >= day){
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return  false;
    }
    /**
     * 校验时间天数
     * @param d1  标准格式 yyyy-MM-dd HH:mm:ss 时间
     * @param day 时间 必须大于多少时间
     * @return
     */
    public static boolean ckeckDayTime(Date d1,long day) {
        try{
            Date d2 = new Date();//转Date
            long diff = d2.getTime() - d1.getTime();//这样得到的差值是毫秒级别
            long days = diff / (1000 * 60 * 60 * 24);
//            long hours = (diff-days*(1000 * 60 * 60 * 24))/(1000* 60 * 60);
//            long minutes = (diff-days*(1000 * 60 * 60 * 24)-hours*(1000* 60 * 60))/(1000* 60);
//            System.out.println(""+days+"天"+hours+"小时"+minutes+"分");
            if(days >= day){
                return true;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return  false;
    }

  

    /**
     * long时间戳装换为Date
     * @param stamp
     * @return
     */
    public  static  Date getDateByLongTime(long stamp){
        long longTime = stamp * 1000;
        return new Date(longTime);
    }

    /**
     * 获取当前时间之前或之后几小时 hour
     * @param hour
     * @return
     */
    public static String getTimeByHour(int hour) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.HOUR_OF_DAY, calendar.get(Calendar.HOUR_OF_DAY) + hour);
        return sdf.format(calendar.getTime());
    }


    /**
     * 求出两个时间的时间差
     * @param stardateStr
     * @param enddateStr
     * @return
     */
    public static boolean getDateStr(String stardateStr,String enddateStr){
        SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);//输入的被转化的时间格式
        Date date1 = new Date();
        Date date2 = date1;
        if(null!=stardateStr){
            try {
                date1 = dff.parse(stardateStr);
            } catch (ParseException e) {
//                date1 = new Date();
            }

        }
      if(null!=enddateStr){
          try {
              date2 = dff.parse(enddateStr);
          } catch (ParseException e) {
//              date2 = new Date();
          }
      }else{
//          Calendar c = Calendar.getInstance();
//          c.setTime(date1);
//          c.add(Calendar.DAY_OF_MONTH, 1);
//          date2 = c.getTime();
      }
        long day=(date2.getTime()-date1.getTime())/(24*60*60*1000);
//        System.out.println(day);
        if(day<=2 && day>0){
            return true;
        }
        return false;
    }

    /**
     * 2019-08-29T08:41:25.367Z 装换为 Date格式 yyyy-MM-dd HH:mm:ss
     * @param dateStr
     * @return
     * @throws ParseException
     */
    public static String getDateStr(String dateStr){
        SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);//输入的被转化的时间格式
        Date date1 = null;
        try {
            date1 = dff.parse(dateStr);
        } catch (ParseException e) {
           date1 = new Date();
        }
        String str1 = dff.format(date1);
        return str1;
    }

    /**
     * 获取当前时间 Date格式 yyyy-MM-dd  自定义
     * @param dayNum  时间 1明天 -1昨天
     * @return
     * @throws ParseException
     */
    public static String getCustomDateStr(Integer dayNum){
        SimpleDateFormat dff = new SimpleDateFormat("yyyy-MM-dd", Locale.CHINA);//输入的被转化的时间格式
        Date today = new Date();
        Date date1 = null;
        try {
            Calendar c = Calendar.getInstance();
            c.setTime(today);
            c.add(Calendar.DAY_OF_MONTH, dayNum);
            date1 = c.getTime();
        } catch (Exception e) {
            date1 = today;
        }
        String str1 = dff.format(date1);
        return str1;
    }

    public static String getDateStrDxie(String dateStr) throws ParseException {
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
        Date date = formatter.parse(dateStr);
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String sDate=sdf.format(date);
        return  sDate;
    }

    /**
     *  获取Date时间
     * @param dateStr
     * @return
     */
    public static Date getDate(String dateStr) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date parse = sdf.parse(dateStr);
            return  parse;
        } catch (ParseException e) {
        }
        return new Date();
    }

    /**
     * 检查 中文时间格式是否正确
     * @param dateStr
     * @return
     * @throws ParseException
     */
    public static String ckeckStringDate(String dateStr) throws ParseException {
        Date parse = sdf.parse(dateStr);//转Date
        String sDate=sdf.format(parse);//转String 标准格式 yyyy-MM-dd HH:mm:ss
        return  sDate;
    }

}

  private static final char SEPARATOR = '_';
    /**
     * 驼峰命名法工具
     * @return
     *    toCamelCase("hello_world") == "helloWorld"
     *    toCapitalizeCamelCase("hello_world") == "HelloWorld"
     *    toUnderScoreCase("helloWorld") = "hello_world"
     */
    public static String toCamelCase(String s) {
        if (s == null) {
            return null;
        }

        s = s.toLowerCase();

        StringBuilder sb = new StringBuilder(s.length());
        boolean upperCase = false;
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == SEPARATOR) {
                upperCase = true;
            } else if (upperCase) {
                sb.append(Character.toUpperCase(c));
                upperCase = false;
            } else {
                sb.append(c);
            }
        }

        return sb.toString();
    }

    /**
   * 驼峰命名法工具
   * @return
   *    toCamelCase("hello_world") == "helloWorld" 
   *    toCapitalizeCamelCase("hello_world") == "HelloWorld"
   *    toUnderScoreCase("helloWorld") = "hello_world"
   */
    public static String toCapitalizeCamelCase(String s) {
        if (s == null) {
            return null;
        }
        s = toCamelCase(s);
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }


/**
   * 下划线转驼峰命名
   */
  public static String toUnderScoreCase(String s)
  {
    if (s == null)
    {
      return null;
    }
    StringBuilder sb = new StringBuilder();
    boolean upperCase = false;
    for (int i = 0; i < s.length(); i++)
    {
      char c = s.charAt(i);

      boolean nextUpperCase = true;

      if (i < (s.length() - 1))
      {
        nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
      }

      if ((i > 0) && Character.isUpperCase(c))
      {
        if (!upperCase || !nextUpperCase)
        {
          sb.append(SEPARATOR);
        }
        upperCase = true;
      }
      else
      {
        upperCase = false;
      }

      sb.append(Character.toLowerCase(c));
    }

    return sb.toString();
  }

//图片处理

/**
     * 依据url 获取 base64的商品图片数组
     * @param urls
     * @return
     */
    public static  LinkedList<String> getImagesToBase64ByOnlineNew(List<String> urls){
        if(NullUtils.isNotNullList(urls)){
            LinkedList<String> base64Pics = new LinkedList<>();//base64商品图集合
            for (String url : urls) {
                try{
                    String s = Base64ImgUtil.ImageToBase64ByOnlineNew(url);
                    base64Pics.add(s);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
            return base64Pics;
        }
        return null;
    }


相关文章
|
1月前
|
SQL 缓存 PHP
PHP技术探究:优化数据库查询效率的实用方法
本文将深入探讨PHP中优化数据库查询效率的实用方法,包括索引优化、SQL语句优化以及缓存机制的应用。通过合理的优化策略和技巧,可以显著提升系统性能,提高用户体验,是PHP开发者不容忽视的重要议题。
|
1月前
|
存储 缓存 NoSQL
利用Redis List实现数据库分页快速查询的有效方法
利用Redis List实现数据库分页快速查询的有效方法
|
1月前
|
设计模式 NoSQL Java
常用的设计模式以及操作Redis、MySQL数据库、各种MQ、数据类型转换的方法
常用的设计模式以及操作Redis、MySQL数据库、各种MQ、数据类型转换的方法
|
1月前
|
SQL 关系型数据库 MySQL
【MySQL】— —熟练掌握用SQL语句实现数据库和基本表的创建。熟练掌握MySQL的安装、客户端登录方法;熟练掌握MySQL的编码、数据类型等基础知识;掌握实体完整性的定义和维护方法、掌握参照完整性
【MySQL】— —熟练掌握用SQL语句实现数据库和基本表的创建。熟练掌握MySQL的安装、客户端登录方法;熟练掌握MySQL的编码、数据类型等基础知识;掌握实体完整性的定义和维护方法、掌握参照完整性
138 1
|
5天前
|
SQL 关系型数据库 MySQL
MYSQL————DDL方法使用(包含在数据库,以及具体数据库表格的一些操纵)
MYSQL————DDL方法使用(包含在数据库,以及具体数据库表格的一些操纵)
|
7天前
|
SQL 数据管理 关系型数据库
数据管理DMS产品使用合集之误删了数据库后,恢复方法有哪些
阿里云数据管理DMS提供了全面的数据管理、数据库运维、数据安全、数据迁移与同步等功能,助力企业高效、安全地进行数据库管理和运维工作。以下是DMS产品使用合集的详细介绍。
|
14天前
|
关系型数据库 MySQL 5G
Mysql数据迁移3个快速方法与数据库恢复
Mysql数据迁移3个快速方法与数据库恢复
20 0
|
15天前
|
数据库 监控 关系型数据库
|
1月前
|
SQL Java 数据库连接
JDBC Java标准库提供的一些api(类+方法) 统一各种数据库提供的api
JDBC Java标准库提供的一些api(类+方法) 统一各种数据库提供的api
20 0
|
1月前
|
存储 大数据 测试技术
矢量数据库的性能测试与评估方法
【4月更文挑战第30天】本文探讨了矢量数据库的性能测试与评估方法,强调其在大数据和AI时代的重要性。文中介绍了负载测试、压力测试、容量测试、功能测试和稳定性测试五大评估方法,以及实施步骤,包括确定测试目标、设计用例、准备环境、执行测试和分析结果。这些方法有助于确保数据库的稳定性和高效性,推动技术发展。

热门文章

最新文章