เครื่องคำนวณชั่วโมงทำงาน

บทนำ

เครื่องคำนวณชั่วโมงทำงานเป็นเครื่องมือที่ทรงพลังที่ออกแบบมาเพื่อช่วยให้คุณสามารถกำหนดจำนวนชั่วโมงทั้งหมดที่ใช้ไปกับงานเฉพาะในช่วงเวลาที่กำหนด เครื่องคำนวณนี้มีความสำคัญสำหรับการจัดการโครงการ การติดตามเวลา และการวิเคราะห์ประสิทธิภาพ โดยการป้อนวันที่เริ่มต้น วันที่สิ้นสุด และจำนวนชั่วโมงที่ทำงานในแต่ละวัน คุณสามารถคำนวณเวลาทั้งหมดที่ลงทุนในกิจกรรมเฉพาะได้อย่างรวดเร็วและแม่นยำ

สูตร

สูตรพื้นฐานสำหรับการคำนวณชั่วโมงทั้งหมดคือ:

$\text{Total Hours} = \text{Number of Days} \times \text{Daily Hours}$

โดยที่:

• Number of Days คือจำนวนวันที่อยู่ระหว่างวันที่เริ่มต้นและวันที่สิ้นสุด (รวมทั้งสองวัน)
• Daily Hours คือจำนวนชั่วโมงเฉลี่ยที่ทำงานในแต่ละวัน

เพื่อคำนวณจำนวนวันที่อยู่ระหว่างวันที่สองวัน เราใช้สูตรดังต่อไปนี้:

$\text{Number of Days} = \text{End Date} - \text{Start Date} + 1$

การบวก 1 จะทำให้แน่ใจว่าทั้งวันที่เริ่มต้นและวันที่สิ้นสุดจะรวมอยู่ในการคำนวณ

การคำนวณ

เครื่องคำนวณจะดำเนินการตามขั้นตอนต่อไปนี้เพื่อคำนวณชั่วโมงทั้งหมด:

1. คำนวณจำนวนวันที่อยู่ระหว่างวันที่เริ่มต้นและวันที่สิ้นสุด (รวมทั้งสองวัน)
2. คูณจำนวนวันด้วยจำนวนชั่วโมงที่ทำงานในแต่ละวัน
3. ปัดเศษผลลัพธ์ให้มีทศนิยมสองตำแหน่งเพื่อความอ่านง่าย

การวิเคราะห์ทางคณิตศาสตร์และกรณีขอบ

มาลงลึกในแง่มุมทางคณิตศาสตร์ของการคำนวณ:

1. การคำนวณความแตกต่างของวันที่: จำนวนวันที่อยู่ระหว่างวันที่สองวันสามารถคำนวณได้โดยใช้สูตรต่อไปนี้: $\text{Days} = \left\lfloor\frac{\text{End Date} - \text{Start Date}}{86400}\right\rfloor + 1$ โดยที่ 86400 คือจำนวนวินาทีในหนึ่งวัน และฟังก์ชัน floor จะทำให้เราได้จำนวนวันเป็นจำนวนเต็ม

2. การจัดการเขตเวลา: เมื่อจัดการกับเขตเวลาที่แตกต่างกัน เราต้องพิจารณาการปรับ UTC: $\text{Adjusted Start} = \text{Start Date} + \text{UTC Offset}_{\text{Start}}$ $\text{Adjusted End} = \text{End Date} + \text{UTC Offset}_{\text{End}}$

3. การปรับเวลาในช่วงเวลาประหยัดแสง (DST): ในช่วงการเปลี่ยนแปลง DST วันหนึ่งอาจมี 23 หรือ 25 ชั่วโมง เพื่อคำนึงถึงเรื่องนี้: $\text{Total Hours} = \sum_{i=1}^{n} (\text{Daily Hours} + \text{DST Adjustment}_i)$ โดยที่ $\text{DST Adjustment}_i$ คือ -1, 0 หรือ 1 ชั่วโมงสำหรับแต่ละวัน

4. วันบางส่วน: สำหรับวันเริ่มต้นและวันสิ้นสุดบางส่วน: $\text{Total Hours} = (\text{Full Days} \times \text{Daily Hours}) + \text{Start Day Hours} + \text{End Day Hours}$

5. ชั่วโมงที่แตกต่างกันในแต่ละวัน: เมื่อจำนวนชั่วโมงในแต่ละวันแตกต่างกัน: $\text{Total Hours} = \sum_{i=1}^{n} \text{Daily Hours}_i$

สูตรเหล่านี้จะช่วยจัดการกับกรณีขอบต่าง ๆ และให้ความเข้าใจที่ครอบคลุมมากขึ้นเกี่ยวกับกระบวนการคำนวณ

กรณีการใช้งาน

เครื่องคำนวณชั่วโมงทำงานมีการใช้งานมากมายในหลายสาขา:

1. การจัดการโครงการ:

   • สถานการณ์: ทีมพัฒนาซอฟต์แวร์ต้องการติดตามเวลาที่ใช้ไปในแต่ละขั้นตอนของโครงการ
   • วิธีแก้ไข: ใช้เครื่องคำนวณเพื่อรวมชั่วโมงที่ใช้ไปในขั้นตอนการออกแบบ การเขียนโค้ด การทดสอบ และการปรับใช้

2. งานฟรีแลนซ์:

   • สถานการณ์: นักออกแบบกราฟิกทำงานในโครงการของลูกค้าหลายโครงการที่มีอัตราค่าบริการที่แตกต่างกัน
   • วิธีแก้ไข: คำนวณชั่วโมงทั้งหมดสำหรับแต่ละโครงการเพื่อกำหนดการเรียกเก็บเงินที่ถูกต้อง

3. การติดตามเวลาของพนักงาน:

   • สถานการณ์: บริษัทผลิตต้องการคำนวณเวลาทำงานล่วงเวลาสำหรับพนักงานที่ทำงานเป็นกะ
   • วิธีแก้ไข: ใช้เครื่องคำนวณเพื่อกำหนดชั่วโมงปกติและเวลาทำงานล่วงเวลาสำหรับการประมวลผลเงินเดือน

4. การวิจัยทางวิชาการ:

   • สถานการณ์: นักศึกษาปริญญาเอกติดตามเวลาที่ใช้ไปในด้านต่าง ๆ ของวิทยานิพนธ์
   • วิธีแก้ไข: คำนวณชั่วโมงที่ใช้ในการทบทวนวรรณกรรม การทดลอง และการเขียน

5. ประสิทธิภาพส่วนบุคคล:

   • สถานการณ์: บุคคลต้องการวิเคราะห์เวลาที่ใช้ไปในกิจกรรมพัฒนาตนเอง
   • วิธีแก้ไข: ติดตามชั่วโมงที่ใช้ไปในกิจกรรมการอ่าน หลักสูตรออนไลน์ และการฝึกทักษะในช่วงหนึ่งเดือน

6. การดูแลสุขภาพ:

   • สถานการณ์: โรงพยาบาลต้องการคำนวณชั่วโมงการทำงานของพยาบาลในแผนกต่าง ๆ
   • วิธีแก้ไข: ใช้เครื่องคำนวณเพื่อกำหนดชั่วโมงทั้งหมดที่พยาบาลทำงานในแต่ละหน่วย

7. การก่อสร้าง:

   • สถานการณ์: บริษัทก่อสร้างต้องการติดตามเวลาการใช้งานอุปกรณ์เพื่อการเรียกเก็บเงิน
   • วิธีแก้ไข: คำนวณชั่วโมงทั้งหมดของการดำเนินงานอุปกรณ์สำหรับแต่ละไซต์โครงการ

8. การวางแผนงาน:

   • สถานการณ์: นักวางแผนงานต้องการคำนวณชั่วโมงการทำงานของพนักงานสำหรับการประชุมหลายวัน
   • วิธีแก้ไข: ใช้เครื่องคำนวณเพื่อกำหนดชั่วโมงการทำงานทั้งหมดสำหรับการตั้งค่า ระยะเวลาการจัดงาน และการเก็บของ

ทางเลือก

แม้ว่าเครื่องคำนวณชั่วโมงทำงานจะมีประโยชน์ในหลายสถานการณ์ แต่ก็มีวิธีการทางเลือกสำหรับการติดตามเวลา:

1. ซอฟต์แวร์ติดตามเวลา:

   • ตัวอย่าง: Toggl, RescueTime, Harvest
   • คุณสมบัติ: การติดตามแบบเรียลไทม์ รายงานที่ละเอียด การรวมเข้ากับเครื่องมือจัดการโครงการ
   • เหมาะสำหรับ: ทีมที่ต้องการการวิเคราะห์เวลาที่ละเอียดและการติดตามตามโครงการ

2. ระบบนาฬิกาเข้า-ออก:

   • ตัวอย่าง: การ์ดเข้า-ออกแบบดั้งเดิม นาฬิกาเวลาแบบดิจิทัล
   • คุณสมบัติ: การติดตามเข้า-ออกอย่างง่าย มักใช้สำหรับการทำงานเป็นกะ
   • เหมาะสำหรับ: สถานที่ทำงานที่มีตารางเวลาคงที่และพนักงานที่ทำงานในสถานที่

3. วิธีการแบบ Agile:

   • ตัวอย่าง: เทคนิค Pomodoro, การกำหนดเวลา
   • คุณสมบัติ: มุ่งเน้นการจัดการเวลาในช่วงเวลาที่เฉพาะเจาะจงแทนที่จะเป็นชั่วโมงทั้งหมด
   • เหมาะสำหรับ: การปรับปรุงประสิทธิภาพและการจัดการงานที่ซับซ้อน

4. แม่แบบสเปรดชีต:

   • ตัวอย่าง: แม่แบบการติดตามเวลาใน Excel หรือ Google Sheets
   • คุณสมบัติ: ปรับแต่งได้ สามารถแชร์และแก้ไขร่วมกันได้
   • เหมาะสำหรับ: ทีมขนาดเล็กหรือบุคคลที่ชื่นชอบการป้อนข้อมูลด้วยตนเอง

5. แอปพลิเคชันมือถือ:

   • ตัวอย่าง: ATracker, Hours Tracker, Timesheet
   • คุณสมบัติ: การติดตามเวลาแบบเคลื่อนที่ มักมีความสามารถ GPS
   • เหมาะสำหรับ: ผู้ทำงานนอกสถานที่หรือผู้ที่ต้องการติดตามเวลาในหลายสถานที่

6. เครื่องมือจัดการโครงการที่มีการติดตามเวลา:

   • ตัวอย่าง: Jira, Asana, Trello ที่มีส่วนเสริมการติดตามเวลา
   • คุณสมบัติ: การติดตามเวลาที่รวมอยู่ในระบบการจัดการงาน
   • เหมาะสำหรับ: ทีมที่ต้องการรวมการจัดการโครงการและการติดตามเวลา

ทางเลือกแต่ละอย่างมีจุดแข็งและเหมาะสมกับสภาพแวดล้อมการทำงานและความต้องการในการติดตามที่แตกต่างกัน การเลือกขึ้นอยู่กับปัจจัยต่าง ๆ เช่น ขนาดทีม ความซับซ้อนของโครงการ และระดับรายละเอียดที่ต้องการในรายงานเวลา

ประวัติ

แนวคิดในการติดตามเวลาและการคำนวณชั่วโมงทำงานมีประวัติศาสตร์ที่ยาวนาน โดยมีความสัมพันธ์ใกล้ชิดกับการพัฒนากฎหมายแรงงานและแนวทางการจัดการโครงการ:

• อารยธรรมโบราณใช้เครื่องวัดเวลาเช่นนาฬิกาแดดและนาฬิกาน้ำเพื่อวัดเวลา แต่การติดตามเวลาทำงานอย่างเป็นทางการยังไม่เป็นที่แพร่หลาย
• การปฏิวัติอุตสาหกรรมในศตวรรษที่ 18 และ 19 ทำให้เกิดความต้องการในการติดตามเวลาอย่างแม่นยำมากขึ้นในโรงงาน
• ในปี 1913 นาฬิกาเวลาเครื่องกลตัวแรกสำหรับติดตามชั่วโมงพนักงานได้รับการจดสิทธิบัตรโดย IBM
• พระราชบัญญัติมาตรฐานแรงงานที่เป็นธรรมของสหรัฐอเมริกาในปี 1938 ได้กำหนดให้มีการจ่ายเงินล่วงเวลา ทำให้การติดตามเวลาอย่างแม่นยำเป็นสิ่งสำคัญสำหรับธุรกิจ
• ในยุคดิจิทัลมีโซลูชันซอฟต์แวร์มากมายสำหรับการติดตามเวลาและการคำนวณชั่วโมง ทำให้กระบวนการมีประสิทธิภาพและแม่นยำยิ่งขึ้น

ในปัจจุบัน ด้วยการเพิ่มขึ้นของการทำงานทางไกลและตารางเวลาที่ยืดหยุ่น เครื่องมืออย่างเครื่องคำนวณชั่วโมงทำงานจึงมีความสำคัญมากขึ้นสำหรับทั้งนายจ้างและพนักงานในการจัดการและวิเคราะห์เวลาทำงานอย่างมีประสิทธิภาพ

ตัวอย่าง

นี่คือตัวอย่างโค้ดเพื่อคำนวณชั่วโมงทั้งหมดสำหรับสถานการณ์ต่าง ๆ:

1' ฟังก์ชัน Excel VBA สำหรับคำนวณชั่วโมงทั้งหมด
2Function CalculateTotalHours(startDate As Date, endDate As Date, dailyHours As Double) As Double
3    Dim days As Long
4    days = DateDiff("d", startDate, endDate) + 1
5    CalculateTotalHours = days * dailyHours
6End Function
7
8' การใช้งาน:
9' =CalculateTotalHours(A1, B1, C1)
10

1from datetime import datetime, timedelta
2
3def calculate_total_hours(start_date, end_date, daily_hours):
4    date_format = "%Y-%m-%d"
5    start = datetime.strptime(start_date, date_format)
6    end = datetime.strptime(end_date, date_format)
7    days = (end - start).days + 1
8    return days * daily_hours
9
10## ตัวอย่างการใช้งาน:
11start_date = "2023-01-01"
12end_date = "2023-01-10"
13daily_hours = 8
14
15total_hours = calculate_total_hours(start_date, end_date, daily_hours)
16print(f"Total Hours: {total_hours:.2f}")
17

1function calculateTotalHours(startDate, endDate, dailyHours) {
2  const start = new Date(startDate);
3  const end = new Date(endDate);
4  const days = (end - start) / (1000 * 60 * 60 * 24) + 1;
5  return days * dailyHours;
6}
7
8// ตัวอย่างการใช้งาน:
9const startDate = '2023-01-01';
10const endDate = '2023-01-10';
11const dailyHours = 8;
12
13const totalHours = calculateTotalHours(startDate, endDate, dailyHours);
14console.log(`Total Hours: ${totalHours.toFixed(2)}`);
15

1import java.time.LocalDate;
2import java.time.temporal.ChronoUnit;
3
4public class HourCalculator {
5    public static double calculateTotalHours(LocalDate startDate, LocalDate endDate, double dailyHours) {
6        long days = ChronoUnit.DAYS.between(startDate, endDate) + 1;
7        return days * dailyHours;
8    }
9
10    public static void main(String[] args) {
11        LocalDate startDate = LocalDate.of(2023, 1, 1);
12        LocalDate endDate = LocalDate.of(2023, 1, 10);
13        double dailyHours = 8.0;
14
15        double totalHours = calculateTotalHours(startDate, endDate, dailyHours);
16        System.out.printf("Total Hours: %.2f%n", totalHours);
17    }
18}
19

1calculate_total_hours <- function(start_date, end_date, daily_hours) {
2  start <- as.Date(start_date)
3  end <- as.Date(end_date)
4  days <- as.numeric(difftime(end, start, units = "days")) + 1
5  total_hours <- days * daily_hours
6  return(total_hours)
7}
8
9## ตัวอย่างการใช้งาน:
10start_date <- "2023-01-01"
11end_date <- "2023-01-10"
12daily_hours <- 8
13
14total_hours <- calculate_total_hours(start_date, end_date, daily_hours)
15cat(sprintf("Total Hours: %.2f\n", total_hours))
16

1function totalHours = calculateTotalHours(startDate, endDate, dailyHours)
2    startDateNum = datenum(startDate);
3    endDateNum = datenum(endDate);
4    days = endDateNum - startDateNum + 1;
5    totalHours = days * dailyHours;
6end
7
8% ตัวอย่างการใช้งาน:
9startDate = '2023-01-01';
10endDate = '2023-01-10';
11dailyHours = 8;
12
13totalHours = calculateTotalHours(startDate, endDate, dailyHours);
14fprintf('Total Hours: %.2f\n', totalHours);
15

1#include <iostream>
2#include <ctime>
3#include <string>
4#include <iomanip>
5
6double calculateTotalHours(const std::string& startDate, const std::string& endDate, double dailyHours) {
7    std::tm start = {}, end = {};
8    std::istringstream ss_start(startDate);
9    std::istringstream ss_end(endDate);
10    ss_start >> std::get_time(&start, "%Y-%m-%d");
11    ss_end >> std::get_time(&end, "%Y-%m-%d");
12    
13    std::time_t start_time = std::mktime(&start);
14    std::time_t end_time = std::mktime(&end);
15    
16    double days = std::difftime(end_time, start_time) / (60 * 60 * 24) + 1;
17    return days * dailyHours;
18}
19
20int main() {
21    std::string startDate = "2023-01-01";
22    std::string endDate = "2023-01-10";
23    double dailyHours = 8.0;
24    
25    double totalHours = calculateTotalHours(startDate, endDate, dailyHours);
26    std::cout << "Total Hours: " << std::fixed << std::setprecision(2) << totalHours << std::endl;
27    
28    return 0;
29}
30

1require 'date'
2
3def calculate_total_hours(start_date, end_date, daily_hours)
4  start = Date.parse(start_date)
5  end_date = Date.parse(end_date)
6  days = (end_date - start).to_i + 1
7  days * daily_hours
8end
9
10## ตัวอย่างการใช้งาน:
11start_date = "2023-01-01"
12end_date = "2023-01-10"
13daily_hours = 8
14
15total_hours = calculate_total_hours(start_date, end_date, daily_hours)
16puts "Total Hours: #{total_hours.round(2)}"
17

1<?php
2
3function calculateTotalHours($startDate, $endDate, $dailyHours) {
4    $start = new DateTime($startDate);
5    $end = new DateTime($endDate);
6    $days = $end->diff($start)->days + 1;
7    return $days * $dailyHours;
8}
9
10// ตัวอย่างการใช้งาน:
11$startDate = '2023-01-01';
12$endDate = '2023-01-10';
13$dailyHours = 8;
14
15$totalHours = calculateTotalHours($startDate, $endDate, $dailyHours);
16echo "Total Hours: " . number_format($totalHours, 2);
17
18?>
19

1use chrono::NaiveDate;
2
3fn calculate_total_hours(start_date: &str, end_date: &str, daily_hours: f64) -> f64 {
4    let start = NaiveDate::parse_from_str(start_date, "%Y-%m-%d").unwrap();
5    let end = NaiveDate::parse_from_str(end_date, "%Y-%m-%d").unwrap();
6    let days = (end - start).num_days() + 1;
7    days as f64 * daily_hours
8}
9
10fn main() {
11    let start_date = "2023-01-01";
12    let end_date = "2023-01-10";
13    let daily_hours = 8.0;
14
15    let total_hours = calculate_total_hours(start_date, end_date, daily_hours);
16    println!("Total Hours: {:.2}", total_hours);
17}
18

1using System;
2
3class HourCalculator
4{
5    static double CalculateTotalHours(DateTime startDate, DateTime endDate, double dailyHours)
6    {
7        int days = (endDate - startDate).Days + 1;
8        return days * dailyHours;
9    }
10
11    static void Main()
12    {
13        DateTime startDate = new DateTime(2023, 1, 1);
14        DateTime endDate = new DateTime(2023, 1, 10);
15        double dailyHours = 8.0;
16
17        double totalHours = CalculateTotalHours(startDate, endDate, dailyHours);
18        Console.WriteLine($"Total Hours: {totalHours:F2}");
19    }
20}
21

1package main
2
3import (
4    "fmt"
5    "time"
6)
7
8func calculateTotalHours(startDate, endDate string, dailyHours float64) float64 {
9    start, _ := time.Parse("2006-01-02", startDate)
10    end, _ := time.Parse("2006-01-02", endDate)
11    days := end.Sub(start).Hours()/24 + 1
12    return days * dailyHours
13}
14
15func main() {
16    startDate := "2023-01-01"
17    endDate := "2023-01-10"
18    dailyHours := 8.0
19
20    totalHours := calculateTotalHours(startDate, endDate, dailyHours)
21    fmt.Printf("Total Hours: %.2f\n", totalHours)
22}
23

1import Foundation
2
3func calculateTotalHours(startDate: String, endDate: String, dailyHours: Double) -> Double {
4    let dateFormatter = DateFormatter()
5    dateFormatter.dateFormat = "yyyy-MM-dd"
6    
7    guard let start = dateFormatter.date(from: startDate),
8          let end = dateFormatter.date(from: endDate) else {
9        return 0
10    }
11    
12    let days = Calendar.current.dateComponents([.day], from: start, to: end).day! + 1
13    return Double(days) * dailyHours
14}
15
16// ตัวอย่างการใช้งาน:
17let startDate = "2023-01-01"
18let endDate = "2023-01-10"
19let dailyHours = 8.0
20
21let totalHours = calculateTotalHours(startDate: startDate, endDate: endDate, dailyHours: dailyHours)
22print(String(format: "Total Hours: %.2f", totalHours))
23

1-- ฟังก์ชัน SQL สำหรับคำนวณชั่วโมงทั้งหมด
2CREATE FUNCTION calculate_total_hours(
3    start_date DATE,
4    end_date DATE,
5    daily_hours DECIMAL(5,2)
6) RETURNS DECIMAL(10,2) AS $$
7BEGIN
8    RETURN (end_date - start_date + 1) * daily_hours;
9END;
10$$ LANGUAGE plpgsql;
11
12-- ตัวอย่างการใช้งาน:
13SELECT calculate_total_hours('2023-01-01', '2023-01-10', 8.0) AS total_hours;
14

ตัวอย่างเหล่านี้แสดงให้เห็นถึงวิธีการคำนวณชั่วโมงทั้งหมดโดยใช้ภาษาการเขียนโปรแกรมต่าง ๆ คุณสามารถปรับฟังก์ชันเหล่านี้ให้เหมาะกับความต้องการเฉพาะของคุณหรือรวมเข้ากับระบบติดตามเวลาที่ใหญ่ขึ้น

ตัวอย่างเชิงตัวเลข

1. สัปดาห์ทำงานมาตรฐาน:

   • วันที่เริ่มต้น: 2023-01-02 (วันจันทร์)
   • วันที่สิ้นสุด: 2023-01-06 (วันศุกร์)
   • ชั่วโมงต่อวัน: 8
   • ชั่วโมงทั้งหมด: 5 วัน * 8 ชั่วโมง = 40 ชั่วโมง

2. โครงการสองสัปดาห์:

   • วันที่เริ่มต้น: 2023-01-01 (วันอาทิตย์)
   • วันที่สิ้นสุด: 2023-01-14 (วันเสาร์)
   • ชั่วโมงต่อวัน: 6
   • ชั่วโมงทั้งหมด: 14 วัน * 6 ชั่วโมง = 84 ชั่วโมง

3. งานที่ยาวนานหนึ่งเดือน:

   • วันที่เริ่มต้น: 2023-02-01
   • วันที่สิ้นสุด: 2023-02-28
   • ชั่วโมงต่อวัน: 4.5
   • ชั่วโมงทั้งหมด: 28 วัน * 4.5 ชั่วโมง = 126 ชั่วโมง

4. การทำงานในวันบางส่วน:

   • วันที่เริ่มต้น: 2023-03-15
   • วันที่สิ้นสุด: 2023-03-15
   • ชั่วโมงต่อวัน: 3.5
   • ชั่วโมงทั้งหมด: 1 วัน * 3.5 ชั่วโมง = 3.5 ชั่วโมง

5. สัปดาห์ทำงานที่มีวันหยุดสุดสัปดาห์:

   • วันที่เริ่มต้น: 2023-03-20 (วันจันทร์)
   • วันที่สิ้นสุด: 2023-03-26 (วันอาทิตย์)
   • ชั่วโมงต่อวัน: 8 (สมมติว่าทำงานเฉพาะในวันทำงาน)
   • ชั่วโมงทั้งหมด: 5 วัน * 8 ชั่วโมง = 40 ชั่วโมง (ไม่รวมวันเสาร์และวันอาทิตย์)

หมายเหตุ: ตัวอย่างนี้สมมติว่าเครื่องคำนวณไม่ได้คำนวณวันหยุดสุดสัปดาห์ ในทางปฏิบัติ เครื่องคำนวณจะต้องมีตรรกะเพิ่มเติมเพื่อจัดการกับวันหยุดสุดสัปดาห์และวันหยุดหากต้องการให้ถูกตัดออกจากการคำนวณ

อ้างอิง

1. "การติดตามเวลา." วิกิพีเดีย, มูลนิธิวิกิมีเดีย, https://en.wikipedia.org/wiki/Time_tracking. เข้าถึงเมื่อ 13 ก.ย. 2024
2. "สถาบันการจัดการโครงการ." PMI, https://www.pmi.org/. เข้าถึงเมื่อ 13 ก.ย. 2024
3. Macan, Therese HoffMacan. "การจัดการเวลา: การทดสอบโมเดลกระบวนการ." วารสารจิตวิทยาประยุกต์ 79.3 (1994): 381.
4. "พระราชบัญญัติมาตรฐานแรงงานที่เป็นธรรมของปี 1938." กระทรวงแรงงานสหรัฐอเมริกา, https://www.dol.gov/agencies/whd/flsa. เข้าถึงเมื่อ 13 ก.ย. 2024.

เวลา (วัน) ชั่วโมง

วันที่เริ่มต้น วันที่สิ้นสุด

ชั่วโมงต่อวัน

ชั่วโมงทั้งหมด