计算请假天数的代码，去掉了假期和下班时间，中间的那个去掉假期的方法可以自己设置，参数arg可以取出请假时间的对象，domain表示this，实际操作可以自己微调，看一下思路就可以。

最新推荐文章于 2021-12-30 14:11:59 发布
最新推荐文章于 2021-12-30 14:11:59 发布
阅读量249 收藏
点赞数
分类专栏： 工作 文章标签： js小方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cc18827511738/article/details/88996633
版权

LBCP.ZHXZ.Leave.jisuantime = function(arg, domain){
    var canshu;
    var AM_UpHour;
    var AM_DownHour;
    var PM_UpHour;
    var PM_DownHour;
    var hour = 60 * 60 * 1000;
    var am1;
    var am2;
    var pm1;
    var pm2;
    if(domain.workflow.getModuleParam()){
        canshu = JSON.parse(domain.workflow.getModuleParam());
        if(canshu.sbsj && canshu.sbsj.am1){
            am1 = canshu.sbsj.am1;
            AM_UpHour = am1 * hour;
        }
        if(canshu.sbsj && canshu.sbsj.am2){
            am2 = canshu.sbsj.am2;
            AM_DownHour = am2 * hour;
        }
        if(canshu.sbsj && canshu.sbsj.pm1){
            pm1 = canshu.sbsj.pm1;
            PM_UpHour = pm1 * hour;
        }
        if(canshu.sbsj && canshu.sbsj.pm2){
            pm2 = canshu.sbsj.pm2;
            PM_DownHour = pm2 * hour;
        }
    } else{
        am1 = 9;
        am2 = 12;
        pm1 = 14;
        pm2 = 18;
        AM_UpHour = 9 * hour;
        AM_DownHour = 12 * hour;
        PM_UpHour = 14 * hour;
        PM_DownHour = 18 * hour;
    }
        var days = 0.0;
        var bTimeStr = arg.begintime1 + arg.begintime2;
        var eTimeStr = arg.endtime1 + arg.endtime2;
        var bDate = new Date(arg.time1);
        var eDate = new Date(arg.time2);
        var bTime = bTimeStr[0] * 10 * hour + bTimeStr[1] * hour
                + bTimeStr[2] * 60 * 10 * 1000 + bTimeStr[3] * 60 * 1000;
        var eTime = eTimeStr[0] * 10 * hour + eTimeStr[1] * hour
                + eTimeStr[2] * 60 * 10 * 1000 + eTimeStr[3] * 60 * 1000;
        var half = 0.5;
        var allDay = 1.0;
        var workh = parseFloat(pm2) - parseFloat(pm1) + parseFloat(am2) - parseFloat(am1);
        // 相隔天数
        var n = (eDate.getTime() - bDate.getTime()) / (hour * 24);
        if (n > 1) {
            days = n - 1;
        }
        // 如果是同一天
        if (arg.time1 == arg.time2) {
            if (bTime <= eTime) {
                if (bTime <= AM_UpHour) {
                    if (eTime <= AM_DownHour && eTime > AM_UpHour) {
                        days += (eTime - AM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                        days += (AM_DownHour - AM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                        days += (AM_DownHour - AM_UpHour + eTime - PM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_DownHour) {
                        days += 1.0;
                    }
                } else if (bTime > AM_UpHour && bTime <= AM_DownHour) {// 大于上午上班时间，小于上午下班时间
                    if (eTime <= AM_DownHour) {
                        days += (eTime - bTime) / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                        days += (AM_DownHour - bTime)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                        days += (AM_DownHour - bTime + eTime - PM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_DownHour) {
                        days += (AM_DownHour - bTime + PM_DownHour - PM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                } else if (bTime > AM_DownHour && bTime <= PM_UpHour) {// 大于上午下班时间，小于下午上班班时间
                    if (eTime <= PM_DownHour) {
                        days += (eTime - PM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_DownHour) {
                        days += (AM_DownHour - PM_UpHour)
                                / (60 * 60 * 1000 * workh);
                    }
                } else if (bTime > PM_UpHour && bTime <= PM_DownHour) {// 大于上午下班时间，小于下午上班班时间
                    if (eTime <= PM_DownHour) {
                        days += (eTime - bTime) / (60 * 60 * 1000 * workh);
                    }
                    if (eTime > PM_DownHour) {
                        days += (AM_DownHour - bTime)
                                / (60 * 60 * 1000 * workh);
                    }
                }
            }
        }
        // 不是同一天
        else {
            if (bTime <= AM_UpHour) {// 1
                if (eTime <= AM_UpHour) {
                    days += 1;
                }
                if (eTime > AM_UpHour && eTime <= AM_DownHour) {
                    days += (1 + (eTime - AM_UpHour)
                            / (60 * 60 * 1000 * workh));
                }
                if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                    days += (1 + (AM_DownHour - AM_UpHour)
                            / (60 * 60 * 1000 * workh));
                }
                if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                    days += (1 + (AM_DownHour - AM_UpHour + eTime - PM_UpHour)
                            / (60 * 60 * 1000 * workh));
                }
                if (eTime > PM_DownHour) {
                    days += 2;
                }
            } else if (bTime > AM_UpHour && bTime <= AM_DownHour) {
                if (eTime <= AM_UpHour) {
                    days += (AM_DownHour - bTime + PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_UpHour && eTime <= AM_DownHour) {
                    days += (AM_DownHour - bTime + PM_DownHour - PM_UpHour
                            + eTime - AM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                    days += (AM_DownHour - bTime + PM_DownHour - PM_UpHour
                            + AM_DownHour - AM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                    days += (AM_DownHour - bTime + PM_DownHour - PM_UpHour
                            + eTime - PM_UpHour + AM_DownHour - AM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_DownHour) {
                    days += (1 + (AM_DownHour - bTime + PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh));
                }
            } else if (bTime > AM_DownHour && bTime <= PM_UpHour) {
                if (eTime <= AM_UpHour) {
                    days += (PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_UpHour && eTime <= AM_DownHour) {
                    days += (eTime - AM_UpHour + PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                    days += (AM_DownHour - AM_UpHour + PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                    days += (PM_DownHour - PM_UpHour + AM_DownHour
                            - AM_UpHour + eTime - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_DownHour) {
                    days += (1 + (PM_DownHour - PM_UpHour)
                            / (60 * 60 * 1000 * workh));
                }
            } else if (bTime > PM_UpHour && bTime <= PM_DownHour) {
                if (eTime <= AM_UpHour) {
                    days += (PM_DownHour - bTime)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_UpHour && eTime <= AM_DownHour) {
                    days += (eTime - AM_UpHour + PM_DownHour - bTime)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                    days += (AM_DownHour - AM_UpHour + PM_DownHour - bTime)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                    days += (PM_DownHour - bTime + AM_DownHour - AM_UpHour
                            + eTime - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_DownHour) {
                    days += (1 + (PM_DownHour - bTime)
                            / (60 * 60 * 1000 * workh));
                }
            } else if (bTime > PM_DownHour) {// PM_DownHour - bTime
                if (eTime > AM_UpHour && eTime <= AM_DownHour) {
                    days += (eTime - AM_UpHour) / (60 * 60 * 1000 * workh);
                }
                if (eTime > AM_DownHour && eTime <= PM_UpHour) {
                    days += (AM_DownHour - AM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_UpHour && eTime <= PM_DownHour) {
                    days += (AM_DownHour - AM_UpHour + eTime - PM_UpHour)
                            / (60 * 60 * 1000 * workh);
                }
                if (eTime > PM_DownHour) {
                    days += 1;
                }
            }
        }
        sttime1 = new Date(arg.time1.replace(/-/g, '/'));
        sttime2 = new Date(arg.time2.replace(/-/g, '/'));
        var aaa = (sttime2 - sttime1)/(60 * 60 * 1000 * 24);
        var ab = arg.time1.split("-");
        var ae = arg.time2.split("-");
        var db = new Date();
        db.setUTCFullYear(ab[0], ab[1] - 1, ab[2]);
        var de = new Date();
        de.setUTCFullYear(ae[0], ae[1] - 1, ae[2]);
        var unixDb = db.getTime();
        var unixDe = de.getTime();
        var i = 0;
        var jianum = 0.0;
        for (var k = unixDb; k <= unixDe;) {
            var date = new Date(parseInt(k));
            var year = date.getFullYear(); 
              var month =(date.getMonth() + 1).toString(); 
              var day = (date.getDate()).toString();  
              if (month.length == 1) { 
                  month = "0" + month; 
              } 
              if (day.length == 1) { 
                  day = "0" + day; 
              }
            var dateTime = year + "-" + month + "-" + day;
            var result = LEAP.request('loap_isworkday', {datestr:dateTime});
            if(result && result.result && result.result[0] == 1){
                if(i == 0){
                    if(bTime <= AM_UpHour){
                        jianum += 1;
                    } else if(bTime > AM_UpHour && bTime <= AM_DownHour){
                        jianum += (PM_DownHour - PM_UpHour + AM_DownHour - bTime)/(60 * 60 * 1000 * workh);
                    } else if(bTime > AM_DownHour && bTime <= PM_UpHour){
                        jianum += (PM_DownHour - PM_UpHour)/(60 * 60 * 1000 * workh);
                    } else if(bTime > PM_UpHour && bTime <= PM_DownHour){
                        jianum += (PM_DownHour - bTime)/(60 * 60 * 1000 * workh);
                    } else if(bTime > PM_DownHour){
                        jianum += 0;
                    }
                } else if(i == aaa){
                    if(eTime <= AM_UpHour){
                        jianum += 0;
                    } else if(eTime > AM_UpHour && eTime <= AM_DownHour){
                        jianum += (eTime - AM_UpHour)/(60 * 60 * 1000 * workh);
                    } else if(eTime > AM_DownHour && eTime <= PM_UpHour){
                        jianum += (AM_DownHour - AM_UpHour)/(60 * 60 * 1000 * workh);
                    } else if(eTime > PM_UpHour && eTime <= PM_DownHour){
                        jianum += (AM_DownHour - AM_UpHour + eTime - PM_UpHour)/(60 * 60 * 1000 * workh);
                    } else if(eTime > PM_DownHour){
                        jianum += 1;
                    }
                } else{
                    jianum += 1;
                }
            }
            if(!result || !result.result){
                var dt = new Date(dateTime.replace(/-/g, '/'));
                if (dt.getDay() == 0 || dt.getDay() == 6){
                //0--sunday, 6--saturday
                    jianum += 1;
                }
            }
            i++;
            k = k + 24 * 60 * 60 * 1000;
        }
        days = days - jianum;
        return days;
}

玄日写代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js 计算请假时长（去除了周六日，节假日未清除）
weixin_30793643的博客
12-26 1183
js 计算请假时长（去除了周六日，节假日未清除） 2017-12-26亦皓 <!DOCTYPE html> <html> <head> <title></title> <meta http-equiv="content-type" content="text/html;charset=utf-8">...
vue.js写请假计算天数，除去周六日以及放假日期
weixin_43591952的博客
07-25 2095
代码】vue.js写请假计算天数，除去周六日以及放假日期。
vue js moment.js 过滤了双休日和法定节假日
weixin_34064653的博客
07-20 1874
源码：注！原创的！！！！ <template> <div id="DATE"> <ul class="dateForm" @change="VpushDateTime((ymd+hour+minute))"> <!-- 年月日 --> <li class="ymd"> &...
js获取工作时间区间天数（不排除节假日）
k20110的专栏
06-01 565
网上查了好几个计算请假天数的方法，发现写的比较复杂还几乎不能用，没办法就自己撸了一个，亲测可用 import moment from "moment"; ConvertDays(beginDay, endDay) { // 制度时间上班、下班、午休时间节点 let begin = 9, end = 17.5, afterBeg = 12, afterEnd = 13.5, total = 7, diff = 1.5; let days = parseInt((momen.
计算2个日期相差天数、去除节假日周末
06-14
拿去可以直接用的计算2个日期间相差天数，并过滤了节假日和周末。
C++中可以接受任意多个参数的函数定义方法(详解)
12-31
能够接受任意多个参数的函数，可以利用重载来实现。这种函数的执行过程类似于递归调用，所以必须要有递归终止条件。 #include #include void print() {} // 递归终止条件。这是必需的。 template void print...
基于Python自相关法时间序列的时间延迟计算
02-11
在时间序列分析中，时间延迟计算是一个关键步骤，特别是在研究混沌系统和进行故障诊断时。本文将深入探讨如何使用Python实现自相关法来确定时间序列的时间延迟。自相关函数是衡量一个时间序列与自身不同时间间隔滞后...
npm-package-arg:解析可以作为`npm install`参数的内容
05-14
npm-package-arg 解析传递给命令（如npm install或npm cache add ）或在package.json依赖项部分中找到的包名称和说明符。 例子 var assert = require ( "assert" ) var npa = require ( "npm-package-arg" ) // ...
vue中格式化时间过滤器代码实例
10-17
过滤器可以有自己的参数，例如： ``` {{ message | filterName('arg1', arg2) }} ``` 现在，我们来看看如何创建一个Vue格式化时间过滤器。在文章的示例代码中，我们首先定义了一个辅助函数 `addZero`，它会检查...
ARGMAX/ARGMIN:这组函数有效地计算向量和矩阵的最大值/最小值参数。-matlab开发
06-01
总结起来，"ARGMAX/ARGMIN:这组函数有效地计算向量和矩阵的最大值/最小值参数"是关于如何利用MATLAB的MEX功能来提高计算效率的一个实例。通过编写并编译C源代码，我们可以创建出比MATLAB内置函数更快的版本，这对于...
PHP 根据时间区间计算请假时长
02-23
根据两个时间戳,计算相差分钟,再加上天数. 跨天主要计算第一天开始时间和最后一天的时间 加上日期相差的天数
请假时长计算和每月工作天数计算源码
12-20
请假时长计算和每月工作天数计算源码 请假时长计算和每月工作天数计算源码
计算请假工时，去除周六周末的时间
Louis_Lu93的博客
05-26 1729
做项目时，写到一个请假的模块，需要计算请假工时，去除周六周末，时间为一天8H，8:00-17:00,中午12：00-13：00 为午休时间 function getLeaveTime(startDate,endDate){ var datetime1 = new Date(startDate), datetime2 = new Date(endDate); var date
去除法定节假日以及周末，计算请假时间
Syntacticsugar's blog
01-23 1950
业务需要，不废话，直接说核心、 直接上最佳解决方案，那就是动态的获取国家法定节假日（每年都会更新，可维护性更强）。并去除周六周末、 当然，有一种比较low的解决方案就是把当年的法定节假日储存到表中或者直接写到配置文件中，比如国庆，除夕等等节日、动态获取国家法定节假日才能够一劳永逸； 网上有一个日期API 说能够调用接口返回json ，但是亲测无卵用，还需大家分辨、 》 接口如下： http:...
请假时间计算----开始时间不是17点之后算一天，排除周日和节假日
Big_xbc的博客
12-30 894
public String calLeaveDays(Date startTime, Date endTime, Integer vacateType) { // Integer vacateType;//请假类型 4是产假 if (vacateType==null) vacateType=6; int leaveDays = 0; //从startTime开始循环，若该日期不是节假日或者不是周六日则请假天数+1 Date fla
php计算跨月请假天数,计算请假天数JavaScript方法
weixin_39566882的博客
04-13 729
前言最近，有这么个需求，给用户做个请假审批系统，要输入请假开始时间和结束时间，同时计算出请假天数，如果年假数量不够提示不能提交，如果年假数量够的话，就走审批工作流，审批通过以后，自动在年假上减去这个请假天数。审批流程很简单，就是找自己的经理审批就好了，在SharePoint里创建一个简单的workflow就可以实现。但是请假天数着实花了点时间，用JavaScript实现了。下面，就把写完的Java...
php请假时间不能有记录,存储过程计算两个时间段的请假天数
weixin_29113371的博客
03-22 232
DELIMITER $$USE`s2cloud`$$DROP PROCEDURE IF EXISTS`pro_get_usedtime_bycalendar`$$CREATE DEFINER=`sqluser`@`%` PROCEDURE `pro_get_usedtime_bycalendar`(IN _calendar_name VARCHAR(50),IN _startDate DATETI...
php计算跨月请假天数,js计算请假天数
weixin_32430941的博客
04-13 191
<th>开始时间：</th><td><?php$form->widget('zii.widgets.jui.CJuiDatePicker', array('model'=>$model,'attribute'=>'begintime','language'=>'zh',// additional javascript options...
java 计算请假天数，去掉节假日
kingkang
10-16 2296
计算请假天数，去掉节假日的 前端 function countDays() { //外出开始日期 var startDate = new Date(DSF.getElementValueByKey("C-OUTMANAGE-0001").replace(/\-/g, "/")); //外出开始日期 var endDate = new Date(DSF.getElementValueByKey("C-OUTMANAGE-0002").replace(/\-/g, "/"));
QT 计算两个QDateTime的时间差，并将时间差显示为时分秒格式文本（小时可以超过24小时）
最新发布
05-30
如果要处理小时数超过 24 小时的情况，可以使用 `QDateTime::daysTo()` 和 `QDateTime::time()` 方法计算天数差和时间差，然后将时间差转换为时分秒格式的文本。 下面是一个示例代码： ```cpp QDateTime dateTime1 = QDateTime::currentDateTime(); QDateTime dateTime2 = QDateTime::fromString("2022-01-03 12:34:56", "yyyy-MM-dd hh:mm:ss"); int daysDiff = dateTime1.daysTo(dateTime2); QTime timeDiff = dateTime1.time().msecsTo(dateTime2.time()) < 0 ? dateTime2.time().addSecs(-1).addMSecs(dateTime1.time().msecsTo(dateTime2.time())) : dateTime1.time().addMSecs(dateTime1.time().msecsTo(dateTime2.time())); QString timeDiffStr = QString("%1:%2:%3") .arg(timeDiff.hour() + daysDiff * 24, 2, 10, QLatin1Char('0')) .arg(timeDiff.minute(), 2, 10, QLatin1Char('0')) .arg(timeDiff.second(), 2, 10, QLatin1Char('0')); qDebug() << timeDiffStr; ``` 这个示例代码会计算当前时间和 2022 年 1 月 3 日 12 点 34 分 56 秒的时间差，并将时间差转换为时分秒格式的文本，可以处理小时数超过 24 小时的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值