ಯುನಿಕ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಕ

// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
function convertUnixTimestamp(timestamp, use12Hour = false) {
  // ಹೊಸ ದಿನಾಂಕ ವಸ್ತುವನ್ನು ರಚಿಸಿ (ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ಬಳಸುತ್ತದೆ)
  const date = new Date(timestamp * 1000);
  
  // ರೂಪಾಂತರ ಆಯ್ಕೆಗಳು
  const options = {
    year: 'numeric',
    month: 'long',
    day: 'numeric',
    weekday: 'long',
    hour: use12Hour ? 'numeric' : '2-digit',
    minute: '2-digit',
    second: '2-digit',
    hour12: use12Hour
  };
  
  // ಸ್ಥಳೀಯ ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಬಳಸಿಕೊಂಡು ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಪರಿವರ್ತಿಸಿ
  return date.toLocaleString(undefined, options);
}

// ಉದಾಹರಣೆಯ ಬಳಕೆ
const timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
console.log(convertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
console.log(convertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ

# ಪೈಥಾನ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
import datetime

def convert_unix_timestamp(timestamp, use_12hour=False):
    # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕ ವಸ್ತುವಾಗಿಗೆ ಪರಿವರ್ತಿಸಿ
    date = datetime.datetime.fromtimestamp(timestamp)
    
    # ದಿನಾಂಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೂಪಿಸಲು
    if use_12hour:
        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
    else:
        format_string = "%A, %B %d, %Y %H:%M:%S"     # 24-ಗಂಟೆ ರೂಪ
    
    return date.strftime(format_string)

# ಉದಾಹರಣೆಯ ಬಳಕೆ
timestamp = 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
print(convert_unix_timestamp(timestamp, False))  # 24-ಗಂಟೆ ರೂಪ
print(convert_unix_timestamp(timestamp, True))   # 12-ಗಂಟೆ ರೂಪ

<?php
// PHP ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
function convertUnixTimestamp($timestamp, $use12Hour = false) {
    // ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
    $formatString = $use12Hour 
        ? 'l, F j, Y g:i:s A'  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
        : 'l, F j, Y H:i:s';   // 24-ಗಂಟೆ ರೂಪ
    
    // ದಿನಾಂಕವನ್ನು ಪರಿವರ್ತಿಸಿ ಮತ್ತು ರೂಪಿಸಿ
    return date($formatString, $timestamp);
}

// ಉದಾಹರಣೆಯ ಬಳಕೆ
$timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
echo convertUnixTimestamp($timestamp, false) . "\n"; // 24-ಗಂಟೆ ರೂಪ
echo convertUnixTimestamp($timestamp, true) . "\n";  // 12-ಗಂಟೆ ರೂಪ
?>

// ಜಾವಾ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class UnixTimestampConverter {
    public static String convertUnixTimestamp(long timestamp, boolean use12Hour) {
        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಇನ್ಸ್ಟಂಟ್‌ಗೆ ಪರಿವರ್ತಿಸಿ, ನಂತರ ಸ್ಥಳೀಯ ದಿನಾಂಕಕ್ಕೆ
        Instant instant = Instant.ofEpochSecond(timestamp);
        LocalDateTime dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        
        // ಅಗತ್ಯವಿರುವ ರೂಪವನ್ನು ಆಧರಿಸಿ ರೂಪಾಂತರಕವನ್ನು ರಚಿಸಿ
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
        );
        
        // ದಿನಾಂಕವನ್ನು ರೂಪಿಸಿ
        return dateTime.format(formatter);
    }
    
    public static void main(String[] args) {
        long timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
        System.out.println(convertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
        System.out.println(convertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ
    }
}

// C# ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
using System;

class UnixTimestampConverter
{
    public static string ConvertUnixTimestamp(long timestamp, bool use12Hour)
    {
        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
        // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1970-01-01 ರಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
        DateTime dateTime = DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
        
        // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
        string formatString = use12Hour 
            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
            : "dddd, MMMM d, yyyy HH:mm:ss";   // 24-ಗಂಟೆ ರೂಪ
        
        // ರೂಪಾಂತರಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
        return dateTime.ToString(formatString);
    }
    
    static void Main()
    {
        long timestamp = 1609459200; // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
        Console.WriteLine(ConvertUnixTimestamp(timestamp, false)); // 24-ಗಂಟೆ ರೂಪ
        Console.WriteLine(ConvertUnixTimestamp(timestamp, true));  // 12-ಗಂಟೆ ರೂಪ
    }
}

# ರೂಬಿ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
require 'time'

def convert_unix_timestamp(timestamp, use_12hour = false)
  # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಟೈಮ್ ವಸ್ತುವಾಗಿಗೆ ಪರಿವರ್ತಿಸಿ
  time = Time.at(timestamp)
  
  # 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಿಸಿ
  if use_12hour
    time.strftime("%A, %B %d, %Y %I:%M:%S %p")  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
  else
    time.strftime("%A, %B %d, %Y %H:%M:%S")     # 24-ಗಂಟೆ ರೂಪ
  end
end

# ಉದಾಹರಣೆಯ ಬಳಕೆ
timestamp = 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
puts convert_unix_timestamp(timestamp, false)  # 24-ಗಂಟೆ ರೂಪ
puts convert_unix_timestamp(timestamp, true)   # 12-ಗಂಟೆ ರೂಪ

// ಗೋ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
package main

import (
    "fmt"
    "time"
)

func convertUnixTimestamp(timestamp int64, use12Hour bool) string {
    // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ಟೈಮ್ ಗೆ ಪರಿವರ್ತಿಸಿ
    t := time.Unix(timestamp, 0)
    
    // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
    formatString := "Monday, January 2, 2006 "
    if use12Hour {
        formatString += "3:04:05 PM"  // 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
    } else {
        formatString += "15:04:05"    // 24-ಗಂಟೆ ರೂಪ
    }
    
    // ರೂಪಿತ ಸಮಯವನ್ನು ಹಿಂತಿರುಗಿಸಿ
    return t.Format(formatString)
}

func main() {
    timestamp := int64(1609459200) // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
    fmt.Println(convertUnixTimestamp(timestamp, false)) // 24-ಗಂಟೆ ರೂಪ
    fmt.Println(convertUnixTimestamp(timestamp, true))  // 12-ಗಂಟೆ ರೂಪ
}

// ಸ್ವಿಫ್ಟ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
import Foundation

func convertUnixTimestamp(_ timestamp: Int, use12Hour: Bool) -> String {
    // ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು ದಿನಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
    let date = Date(timeIntervalSince1970: TimeInterval(timestamp))
    
    // ದಿನಾಂಕ ರೂಪಾಂತರಕವನ್ನು ರಚಿಸಿ
    let formatter = DateFormatter()
    formatter.dateStyle = .full
    
    // 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ಸಮಯ ಶೈಲಿಯನ್ನು ಹೊಂದಿಸಿ
    if use12Hour {
        formatter.timeStyle = .medium
        formatter.amSymbol = "AM"
        formatter.pmSymbol = "PM"
    } else {
        formatter.timeStyle = .medium
        formatter.dateFormat = formatter.dateFormat?.replacingOccurrences(of: "h:mm:ss a", with: "HH:mm:ss")
    }
    
    // ರೂಪಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
    return formatter.string(from: date)
}

// ಉದಾಹರಣೆಯ ಬಳಕೆ
let timestamp = 1609459200 // 2021ರ ಜನವರಿ 1, 00:00:00 UTC
print(convertUnixTimestamp(timestamp, use12Hour: false)) // 24-ಗಂಟೆ ರೂಪ
print(convertUnixTimestamp(timestamp, use12Hour: true))  // 12-ಗಂಟೆ ರೂಪ

# ಆರ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
convert_unix_timestamp <- function(timestamp, use_12hour = FALSE) {
  # ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು POSIXct ದಿನಾಂಕ/ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
  date_time <- as.POSIXct(timestamp, origin = "1970-01-01", tz = "UTC")
  
  # 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಿಸಿ
  if (use_12hour) {
    format_string <- "%A, %B %d, %Y %I:%M:%S %p"  # 12-ಗಂಟೆ ರೂಪ ಎಎಂ/ಪಿಎಂ
  } else {
    format_string <- "%A, %B %d, %Y %H:%M:%S"     # 24-ಗಂಟೆ ರೂಪ
  }
  
  # ರೂಪಿತ ದಿನಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ
  format(date_time, format_string)
}

# ಉದಾಹರಣೆಯ ಬಳಕೆ
timestamp <- 1609459200  # 2021ರ ಜನವರಿ 1, 00:00:00 UTC
cat(convert_unix_timestamp(timestamp, FALSE), "\n")  # 24-ಗಂಟೆ ರೂಪ
cat(convert_unix_timestamp(timestamp, TRUE), "\n")   # 12-ಗಂಟೆ ರೂಪ

% MATLAB ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತನೆ
function formattedDate = convertUnixTimestamp(timestamp, use12Hour)
    % ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಅನ್ನು MATLAB ದಿನಾಂಕ/ಸಮಯಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
    % MATLAB ದಿನಾಂಕಗಳು 1900-01-01 ರಿಂದ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ, 1 = 1900-01-01
    % ಯುನಿಕ್ಸ್ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 1970-01-01 ರಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
    
    % ಮೊದಲು Excel ದಿನಾಂಕ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಿ
    % 25569 1900-01-01 ಮತ್ತು 1970-01-01 ನಡುವಿನ ದಿನಗಳ ಸಂಖ್ಯೆಯಾಗಿದೆ
    Dim excelDate As Double
    excelDate = (timestamp / 86400) + 25569;
    
    % 12-ಗಂಟೆ ಅಥವಾ 24-ಗಂಟೆ ಆದ್ಯತೆ ಆಧರಿಸಿ ರೂಪಾಂತರ ಸ್ಟ್ರಿಂಗ್
    If use12Hour Then
        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy h:mm:ss AM/PM');
    Else
        formattedDate = datestr(excelDate, 'dddd, mmmm dd, yyyy hh:mm:ss');
    End If
end

% ಕಾರ್ಯಕ್ಷೇತ್ರದಲ್ಲಿ ಬಳಕೆ:
% =ConvertUnixTimestamp(1609459200, TRUE)  ' 12-ಗಂಟೆ ರೂಪ
% =ConvertUnixTimestamp(1609459200, FALSE) ' 24-ಗಂಟೆ ರೂಪ

// ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಎಡ್ಜ್ ಕೇಸ್ ನಿರ್ವಹಣೆ
function safeConvertTimestamp(timestamp, use12Hour = false) {
  // ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಮಾನ್ಯವಾದುದೇ ಎಂದು ಪರಿಶೀಲಿಸಿ
  if (timestamp === undefined || timestamp === null || isNaN(timestamp)) {
    return "ಅಮಾನ್ಯ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್";
  }
  
  // ನಕಾರಾತ್ಮಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ (1970ರ ಮುಂಚಿನ ದಿನಾಂಕಗಳು)
  if (timestamp < 0) {
    // ಕೆಲವು ಬ್ರೌಸರ್‌ಗಳು ನಕಾರಾತ್ಮಕ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳನ್ನು ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸುತ್ತವೆ
    // 1970ರ ಮುಂಚಿನ ದಿನಾಂಕಗಳಿಗಾಗಿ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ವಿಧಾನವನ್ನು ಬಳಸಿರಿ
    const date = new Date(timestamp * 1000);
    if (isNaN(date.getTime())) {
      return "ಅಮಾನ್ಯ ದಿನಾಂಕ (1970ರ ಮುಂಚೆ)";
    }
  }
  
  // Y2K38 ಸಮಸ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸಿ (32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಗಳಿಗಾಗಿ)
  const maxInt32 = 2147483647; // 32-ಬಿಟ್ ಸಹಿ ಸಂಪೂರ್ಣ ಸಂಖ್ಯೆಯ ಗರಿಷ್ಠ ಮೌಲ್ಯ
  if (timestamp > maxInt32) {
    // ಆಧುನಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಬಹಳ ದೊಡ್ಡ ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ಗಳಿಗಾಗಿ BigInt ಅನ್ನು ಬಳಸಲು ಪರಿಗಣಿಸಿ
    console.warn("ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ 32-ಬಿಟ್ ಪೂರ್ಣಾಂಕ ಮಿತಿಯನ್ನು ಮೀರಿಸುತ್ತದೆ (Y2K38 ಸಮಸ್ಯೆ)");
  }
  
  // ಸಾಮಾನ್ಯ ಪರಿವರ್ತನೆಯೊಂದಿಗೆ ಮುಂದುವರಿಯಿರಿ
  try {
    const date = new Date(timestamp * 1000);
    const options = {
      year: 'numeric',
      month: 'long',
      day: 'numeric',
      weekday: 'long',
      hour: use12Hour ? 'numeric' : '2-digit',
      minute: '2-digit',
      second: '2-digit',
      hour12: use12Hour
    };
    return date.toLocaleString(undefined, options);
  } catch (error) {
    return "ಟೈಮ್‌ಸ್ಟ್ಯಾಂಪ್ ಪರಿವರ್ತಿಸುವಾಗ ದೋಷ: " + error.message;
  }
}