محول الطوابع الزمنية في يونكس

مقدمة

الطابع الزمني في يونكس (المعروف أيضًا باسم وقت POSIX أو وقت Epoch) هو نظام لوصف نقطة في الزمن. إنه عدد الثواني التي مرت منذ 1 يناير 1970 (منتصف الليل UTC/GMT)، دون احتساب الثواني الكبيسة. تُستخدم الطوابع الزمنية في يونكس على نطاق واسع في أنظمة الكمبيوتر ولغات البرمجة لأنها توفر تمثيلًا مضغوطًا ومستقلًا عن اللغة للحظة معينة في الزمن.

يكتشف هذا المحول للطابع الزمني إلى تاريخ تلقائيًا ويعالج الطوابع الزمنية بأطوال مختلفة، بما في ذلك دقة الميكروثانية (16 رقمًا)، ودقة الملي ثانية (13 رقمًا)، والطوابع الزمنية القياسية في يونكس (10 أرقام). يحدد الأداة تنسيق الطابع الزمني بناءً على طول الإدخال، ويقوم بتحويله إلى تنسيق تاريخ ووقت قابل للقراءة البشرية، ويعرض النتيجة دون الحاجة إلى أن يحدد المستخدمون نوع الطابع الزمني. يدعم كل من تنسيقات الوقت 12 ساعة (AM/PM) و24 ساعة لتلبية التفضيلات الإقليمية والشخصية المختلفة.

كيفية عمل الطوابع الزمنية في يونكس

يتم حساب الطوابع الزمنية في يونكس على أنها عدد الثواني منذ بداية يونكس (1 يناير 1970، 00:00:00 UTC). وهذا يجعلها مفيدة بشكل خاص لحساب الفروق الزمنية ولتخزين التواريخ بتنسيق مضغوط.

تشمل عملية التحويل الرياضية من الطابع الزمني في يونكس إلى تاريخ تقويمي عدة خطوات:

1. ابدأ مع بداية يونكس (1 يناير 1970، 00:00:00 UTC)
2. أضف عدد الثواني في الطابع الزمني
3. احسب السنوات الكبيسة، وأطوال الأشهر المتغيرة، وتعقيدات التقويم الأخرى
4. طبق تعديلات المنطقة الزمنية إذا لزم الأمر

على سبيل المثال، يمثل الطابع الزمني في يونكس 1609459200 يوم الجمعة، 1 يناير 2021، 00:00:00 UTC.

يمكن التعبير عن صيغة التحويل كالتالي:

$\text{التاريخ} = \text{بداية يونكس} + \text{الطابع الزمني (بالثواني)}$

توفر معظم لغات البرمجة وأنظمة التشغيل وظائف مدمجة للتعامل مع هذا التحويل، مما يخفف من تعقيدات حسابات التقويم.

تنسيقات الطوابع الزمنية والاكتشاف التلقائي

يدعم محولنا ثلاثة تنسيقات شائعة للطوابع الزمنية، والتي يتم اكتشافها تلقائيًا بناءً على عدد الأرقام:

1. الطابع الزمني القياسي في يونكس (10 أرقام): يمثل الثواني منذ بداية يونكس. مثال: 1609459200 (1 يناير 2021، 00:00:00 UTC)

2. دقة الملي ثانية (13 رقمًا): تمثل الملي ثواني منذ بداية يونكس. مثال: 1609459200000 (1 يناير 2021، 00:00:00 UTC)

3. دقة الميكروثانية (16 رقمًا): تمثل الميكروثواني منذ بداية يونكس. مثال: 1609459200000000 (1 يناير 2021، 00:00:00 UTC)

يعمل الاكتشاف التلقائي من خلال تحليل طول الإدخال:

• إذا كان الإدخال يحتوي على 10 أرقام، يتم اعتباره كطابع زمني قياسي في يونكس (بالثواني)
• إذا كان الإدخال يحتوي على 13 رقمًا، يتم اعتباره كطابع زمني بالملي ثانية
• إذا كان الإدخال يحتوي على 16 رقمًا، يتم اعتباره كطابع زمني بالميكروثانية

يُزيل هذا الاكتشاف التلقائي الحاجة إلى أن يحدد المستخدمون نوع الطابع الزمني، مما يجعل الأداة أكثر سهولة وكفاءة.

خيارات تنسيق الوقت

يقدم هذا المحول خيارين لتنسيق الوقت:

1. تنسيق 24 ساعة (يسمى أحيانًا "وقت عسكري"): تتراوح الساعات من 0 إلى 23، ولا يوجد تمييز AM/PM. على سبيل المثال، يتم تمثيل الساعة 3:00 مساءً كـ 15:00.

2. تنسيق 12 ساعة: تتراوح الساعات من 1 إلى 12، مع AM (ante meridiem) للأوقات من منتصف الليل إلى الظهر، وPM (post meridiem) للأوقات من الظهر إلى منتصف الليل. على سبيل المثال، يتم تمثيل الساعة 15:00 في تنسيق 24 ساعة كـ 3:00 مساءً.

تتعلق الاختيار بين هذه التنسيقات غالبًا بالعرف الإقليمي والتفضيلات الشخصية:

• يُستخدم تنسيق 24 ساعة بشكل شائع في معظم أوروبا وأمريكا اللاتينية وآسيا، بالإضافة إلى السياقات العلمية والعسكرية والطبية في جميع أنحاء العالم.
• يُستخدم تنسيق 12 ساعة بشكل شائع في الولايات المتحدة وكندا وأستراليا وبعض البلدان الناطقة باللغة الإنجليزية للاستخدام اليومي.

الحالات الحدية والقيود

عند العمل مع الطوابع الزمنية في يونكس بمختلف الدقات، من المهم أن تكون على دراية بعدة حالات حدية وقيود:

1. الطوابع الزمنية السلبية: تمثل هذه التواريخ قبل بداية يونكس (1 يناير 1970). على الرغم من أنها صحيحة رياضيًا، قد لا تتعامل بعض الأنظمة مع الطوابع الزمنية السلبية بشكل صحيح. ينطبق هذا على جميع تنسيقات الطوابع الزمنية الثلاثة.

2. مشكلة عام 2038: غالبًا ما يتم تخزين الطوابع الزمنية القياسية في يونكس (10 أرقام) كأعداد صحيحة موقعة 32 بت، والتي ستفيض في 19 يناير 2038. بعد هذه النقطة، لن تكون الأنظمة 32 بت قادرة على تمثيل الأوقات بشكل صحيح ما لم يتم تعديلها لاستخدام نوع عدد أكبر.

3. اعتبارات الدقة:

   • الطوابع الزمنية القياسية (10 أرقام) لها دقة على مستوى الثواني، وهو ما يكفي لمعظم التطبيقات اليومية.
   • الطوابع الزمنية بالملي ثانية (13 رقمًا) توفر دقة أكبر بمقدار 1000 مرة، وهو ما يُستخدم في التطبيقات التي تتطلب توقيتًا أكثر دقة.
   • الطوابع الزمنية بالميكروثانية (16 رقمًا) تقدم دقة أكبر (1 من 1,000,000 من الثانية)، وهو ما يُعتبر ضروريًا للحوسبة عالية الأداء، والتطبيقات العلمية، وبعض المعاملات المالية.

4. الطوابع الزمنية الكبيرة جدًا: قد لا يمكن تمثيل تواريخ مستقبلية بعيدة جدًا في بعض الأنظمة، أو قد يتم التعامل معها بشكل غير متسق. وهذا ينطبق بشكل خاص على الطوابع الزمنية بالملي ثانية والميكروثانية، التي تستخدم قيم عددية أكبر.

5. الثواني الكبيسة: لا تأخذ الوقت في يونكس في الاعتبار الثواني الكبيسة، التي تُضاف أحيانًا إلى UTC لتعويض الدوران غير المنتظم للأرض. وهذا يعني أن الوقت في يونكس ليس متزامنًا بدقة مع الوقت الفلكي.

6. اعتبارات المنطقة الزمنية: تمثل الطوابع الزمنية في يونكس لحظات في UTC. يتطلب التحويل إلى الوقت المحلي معلومات إضافية عن المنطقة الزمنية.

7. توقيت التوفير الصيفي: عند تحويل الطوابع الزمنية إلى الوقت المحلي، يجب أخذ تعقيدات انتقالات توقيت التوفير الصيفي في الاعتبار.

8. ارتباك تنسيق الطابع الزمني: بدون الكشف المناسب، قد يتم تفسير الطابع الزمني بالملي ثانية المكون من 13 رقمًا بشكل خاطئ كموعد مستقبلي بعيد إذا تم التعامل معه كطابع زمني قائم على الثواني. يمنع محولنا ذلك من خلال اكتشاف التنسيق تلقائيًا بناءً على طول الرقم.

حالات الاستخدام

تُستخدم الطوابع الزمنية في يونكس بمختلف الدقات في العديد من التطبيقات عبر الحوسبة وإدارة البيانات:

1. سجلات قواعد البيانات: تُستخدم الطوابع الزمنية بشكل شائع لتسجيل متى تم إنشاء الإدخالات أو تعديلها.

   • غالبًا ما تكون الطوابع الزمنية القياسية (10 أرقام) كافية للتطبيقات العامة في قواعد البيانات.
   • تُستخدم الطوابع الزمنية بالملي ثانية (13 رقمًا) عندما يكون من الضروري ترتيب الأحداث بدقة أكبر.

2. تطوير الويب: غالبًا ما تستخدم رؤوس HTTP، وملفات تعريف الارتباط، وآليات التخزين المؤقت الطوابع الزمنية في يونكس.

   • تُرجع دالة Date.now() في JavaScript الطوابع الزمنية بالملي ثانية (13 رقمًا).

3. ملفات السجل: تسجل سجلات النظام الأحداث عادةً باستخدام الطوابع الزمنية في يونكس لترتيب زمني دقيق.

   • قد تستخدم أنظمة التسجيل عالية التردد دقة الملي ثانية أو الميكروثانية.

4. أنظمة التحكم في الإصدارات: تستخدم Git وأنظمة التحكم في الإصدارات الأخرى الطوابع الزمنية لتسجيل متى تم إجراء الالتزامات.

5. استجابات واجهة برمجة التطبيقات: تتضمن العديد من واجهات برمجة التطبيقات على الويب الطوابع الزمنية في استجاباتها للإشارة إلى متى تم إنشاء البيانات أو متى تم تعديل الموارد آخر مرة.

   • غالبًا ما تستخدم واجهات برمجة التطبيقات REST الطوابع الزمنية بدقة الملي ثانية.

6. أنظمة الملفات: غالبًا ما يتم تخزين أوقات إنشاء وتعديل الملفات كطوابع زمنية في يونكس.

7. إدارة الجلسات: تستخدم التطبيقات الويب الطوابع الزمنية لتحديد متى يجب أن تنتهي جلسات المستخدم.

8. تحليل البيانات: توفر الطوابع الزمنية وسيلة موحدة للعمل مع البيانات الزمنية في تطبيقات التحليلات.

9. التداول عالي التردد: تتطلب الأنظمة المالية غالبًا دقة الميكروثانية (16 رقمًا) لترتيب المعاملات بدقة.

10. القياسات العلمية: قد تسجل المعدات البحثية الملاحظات بدقة الميكروثانية من أجل تحليل زمني دقيق.

البدائل

بينما تُستخدم الطوابع الزمنية في يونكس على نطاق واسع، هناك تنسيقات بديلة لتمثيل الوقت قد تكون أكثر ملاءمة في سياقات معينة:

1. ISO 8601: تنسيق سلسلة موحد (مثل "2021-01-01T00:00:00Z") يكون قابلًا للقراءة البشرية مع الحفاظ على إمكانية الترتيب. يُفضل غالبًا لتبادل البيانات والتطبيقات التي تواجه المستخدم.

2. RFC 3339: ملف ISO 8601 المستخدم في بروتوكولات الإنترنت، مع متطلبات تنسيق أكثر صرامة.

3. التنسيقات القابلة للقراءة البشرية: سلاسل التاريخ المحلية (مثل "1 يناير 2021") أكثر ملاءمة للتفاعل المباشر مع المستخدم ولكنها أقل ملاءمة للحساب.

4. FILETIME من مايكروسوفت: قيمة 64 بت تمثل عدد الفترات الزمنية التي تبلغ 100 نانوثانية منذ 1 يناير 1601، تُستخدم في أنظمة ويندوز.

5. رقم اليوم الجولياني: يُستخدم في علم الفلك وبعض التطبيقات العلمية، ويحسب الأيام منذ 1 يناير 4713 قبل الميلاد.

يعتمد اختيار تنسيق الوقت على عوامل مثل:

• الدقة المطلوبة
• احتياجات القراءة البشرية
• قيود التخزين
• التوافق مع الأنظمة الحالية
• نطاق التواريخ التي تحتاج إلى تمثيلها

التاريخ

نشأت فكرة الوقت في يونكس مع تطوير نظام التشغيل يونكس في مختبرات بيل في أواخر الستينيات وأوائل السبعينيات. كان القرار باستخدام 1 يناير 1970 كبداية زمنية أمرًا عشوائيًا إلى حد ما ولكنه عملي في ذلك الوقت - كان قريبًا بما يكفي لتقليل متطلبات التخزين للتواريخ ذات الأهمية ولكن بعيدًا بما يكفي في الماضي ليكون مفيدًا للبيانات التاريخية.

استخدمت التنفيذ الأصلي عددًا صحيحًا موقعة 32 بت لتخزين عدد الثواني، وهو ما كان كافيًا لعمر نظام يونكس المتوقع في ذلك الوقت. ومع ذلك، أدى هذا القرار إلى مشكلة عام 2038 (المعروفة أحيانًا باسم "Y2K38" أو "خطأ الألفية في يونكس")، حيث يمكن أن تمثل الأعداد الصحيحة الموقعة 32 بت التواريخ فقط حتى 19 يناير 2038 (03:14:07 UTC).

مع تطور احتياجات الحوسبة، أصبحت الطوابع الزمنية بدقة أعلى ضرورية:

• أصبحت دقة الملي ثانية (13 رقمًا) شائعة مع ظهور الحوسبة التفاعلية والحاجة إلى قياس استجابة واجهة المستخدم.

• ظهرت دقة الميكروثانية (16 رقمًا) مع التطبيقات الحاسوبية عالية الأداء والأنظمة التي تتطلب توقيتًا دقيقًا للغاية.

مع زيادة شعبية أنظمة يونكس وأنظمة التشغيل الشبيهة بيونكس، أصبحت الطوابع الزمنية في يونكس معيارًا فعليًا لتمثيل الوقت في الحوسبة. تم اعتمادها من قبل العديد من لغات البرمجة وقواعد البيانات والتطبيقات، ممتدة بعيدًا عن بيئتها الأصلية في يونكس.

تستخدم الأنظمة الحديثة بشكل متزايد أعدادًا صحيحة 64 بت للطوابع الزمنية، مما يوسع النطاق القابل للتمثيل إلى حوالي 292 مليار سنة في كلا الاتجاهين من البداية، مما يحل فعليًا مشكلة عام 2038. ومع ذلك، قد تظل الأنظمة والتطبيقات القديمة عرضة للخطر.

لقد ضمنت بساطة وفائدة الطابع الزمني في يونكس استمراره في الصلة رغم تطوير تنسيقات تمثيل الوقت الأكثر تعقيدًا. لا يزال مفهومًا أساسيًا في الحوسبة، يدعم الكثير من بنيتنا التحتية الرقمية.

أمثلة على التعليمات البرمجية

إليك أمثلة على كيفية تحويل الطوابع الزمنية في يونكس بمختلف الدقات إلى تواريخ قابلة للقراءة البشرية في لغات برمجة مختلفة:

1// تحويل الطابع الزمني في JavaScript مع اكتشاف تنسيق تلقائي
2function convertTimestamp(timestamp, use12Hour = false) {
3  // تحويل السلسلة إلى رقم إذا لزم الأمر
4  const numericTimestamp = Number(timestamp);
5  
6  // اكتشاف تنسيق الطابع الزمني بناءً على طول الرقم
7  let date;
8  if (timestamp.length === 16) {
9    // دقة الميكروثانية (قسم على 1,000,000 للحصول على الثواني)
10    date = new Date(numericTimestamp / 1000);
11    console.log("تم الكشف: الطابع الزمني بدقة الميكروثانية");
12  } else if (timestamp.length === 13) {
13    // دقة الملي ثانية
14    date = new Date(numericTimestamp);
15    console.log("تم الكشف: الطابع الزمني بدقة الملي ثانية");
16  } else if (timestamp.length === 10) {
17    // الطابع الزمني القياسي في يونكس (بالثواني)
18    date = new Date(numericTimestamp * 1000);
19    console.log("تم الكشف: الطابع الزمني القياسي في يونكس (بالثواني)");
20  } else {
21    throw new Error("تنسيق الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.");
22  }
23  
24  // خيارات التنسيق
25  const options = {
26    year: 'numeric',
27    month: 'long',
28    day: 'numeric',
29    weekday: 'long',
30    hour: use12Hour ? 'numeric' : '2-digit',
31    minute: '2-digit',
32    second: '2-digit',
33    hour12: use12Hour
34  };
35  
36  // تحويل إلى سلسلة باستخدام تنسيق المنطقة
37  return date.toLocaleString(undefined, options);
38}
39
40// مثال على الاستخدام
41try {
42  // الطابع الزمني القياسي في يونكس (10 أرقام)
43  console.log(convertTimestamp("1609459200", false)); 
44  
45  // دقة الملي ثانية (13 رقمًا)
46  console.log(convertTimestamp("1609459200000", false)); 
47  
48  // دقة الميكروثانية (16 رقمًا)
49  console.log(convertTimestamp("1609459200000000", true)); 
50} catch (error) {
51  console.error(error.message);
52}
53

1# تحويل الطابع الزمني في Python مع اكتشاف تنسيق تلقائي
2import datetime
3
4def convert_timestamp(timestamp, use_12hour=False):
5    # تحويل إلى عدد صحيح
6    timestamp = str(timestamp).strip()
7    numeric_timestamp = int(timestamp)
8    
9    # اكتشاف تنسيق الطابع الزمني بناءً على طول الرقم
10    if len(timestamp) == 16:
11        # دقة الميكروثانية (قسم على 1,000,000 للحصول على الثواني)
12        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000000)
13        print("تم الكشف: الطابع الزمني بدقة الميكروثانية")
14    elif len(timestamp) == 13:
15        # دقة الملي ثانية (قسم على 1,000 للحصول على الثواني)
16        date = datetime.datetime.fromtimestamp(numeric_timestamp / 1000)
17        print("تم الكشف: الطابع الزمني بدقة الملي ثانية")
18    elif len(timestamp) == 10:
19        # الطابع الزمني القياسي في يونكس (بالثواني)
20        date = datetime.datetime.fromtimestamp(numeric_timestamp)
21        print("تم الكشف: الطابع الزمني القياسي في يونكس (بالثواني)")
22    else:
23        raise ValueError("تنسيق الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.")
24    
25    # تنسيق سلسلة التاريخ
26    if use_12hour:
27        format_string = "%A, %B %d, %Y %I:%M:%S %p"  # تنسيق 12 ساعة مع AM/PM
28    else:
29        format_string = "%A, %B %d, %Y %H:%M:%S"     # تنسيق 24 ساعة
30    
31    return date.strftime(format_string)
32
33# مثال على الاستخدام
34try:
35    # الطابع الزمني القياسي في يونكس (10 أرقام)
36    print(convert_timestamp("1609459200", False))
37    
38    # دقة الملي ثانية (13 رقمًا)
39    print(convert_timestamp("1609459200000", False))
40    
41    # دقة الميكروثانية (16 رقمًا)
42    print(convert_timestamp("1609459200000000", True))
43except ValueError as e:
44    print(e)
45

1<?php
2// تحويل الطابع الزمني في PHP مع اكتشاف تنسيق تلقائي
3function convertTimestamp($timestamp, $use12Hour = false) {
4    // تأكد من أن الطابع الزمني سلسلة للتحقق من الطول
5    $timestamp = trim((string)$timestamp);
6    
7    // اكتشاف تنسيق الطابع الزمني بناءً على طول الرقم
8    if (strlen($timestamp) === 16) {
9        // دقة الميكروثانية (قسم على 1,000,000 للحصول على الثواني)
10        $seconds = (float)$timestamp / 1000000;
11        echo "تم الكشف: الطابع الزمني بدقة الميكروثانية\n";
12    } elseif (strlen($timestamp) === 13) {
13        // دقة الملي ثانية (قسم على 1,000 للحصول على الثواني)
14        $seconds = (float)$timestamp / 1000;
15        echo "تم الكشف: الطابع الزمني بدقة الملي ثانية\n";
16    } elseif (strlen($timestamp) === 10) {
17        // الطابع الزمني القياسي في يونكس (بالثواني)
18        $seconds = (float)$timestamp;
19        echo "تم الكشف: الطابع الزمني القياسي في يونكس (بالثواني)\n";
20    } else {
21        throw new Exception("تنسيق الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.");
22    }
23    
24    // تنسيق السلسلة
25    $formatString = $use12Hour 
26        ? 'l, F j, Y g:i:s A'  // تنسيق 12 ساعة مع AM/PM
27        : 'l, F j, Y H:i:s';   // تنسيق 24 ساعة
28    
29    // تحويل وتنسيق التاريخ
30    return date($formatString, $seconds);
31}
32
33// مثال على الاستخدام
34try {
35    // الطابع الزمني القياسي في يونكس (10 أرقام)
36    echo convertTimestamp("1609459200", false) . "\n";
37    
38    // دقة الملي ثانية (13 رقمًا)
39    echo convertTimestamp("1609459200000", false) . "\n";
40    
41    // دقة الميكروثانية (16 رقمًا)
42    echo convertTimestamp("1609459200000000", true) . "\n";
43} catch (Exception $e) {
44    echo $e->getMessage() . "\n";
45}
46?>
47

1// تحويل الطابع الزمني في Java مع اكتشاف تنسيق تلقائي
2import java.time.Instant;
3import java.time.LocalDateTime;
4import java.time.ZoneId;
5import java.time.format.DateTimeFormatter;
6
7public class TimestampConverter {
8    public static String convertTimestamp(String timestamp, boolean use12Hour) {
9        // قم بتقليم الإدخال
10        timestamp = timestamp.trim();
11        
12        // اكتشاف تنسيق الطابع الزمني بناءً على طول الرقم
13        LocalDateTime dateTime;
14        if (timestamp.length() == 16) {
15            // دقة الميكروثانية (قسم على 1,000,000 للحصول على الثواني)
16            long microseconds = Long.parseLong(timestamp);
17            Instant instant = Instant.ofEpochSecond(0, microseconds * 1000); // تحويل إلى نانوثانية
18            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
19            System.out.println("تم الكشف: الطابع الزمني بدقة الميكروثانية");
20        } else if (timestamp.length() == 13) {
21            // دقة الملي ثانية
22            long milliseconds = Long.parseLong(timestamp);
23            Instant instant = Instant.ofEpochMilli(milliseconds);
24            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
25            System.out.println("تم الكشف: الطابع الزمني بدقة الملي ثانية");
26        } else if (timestamp.length() == 10) {
27            // الطابع الزمني القياسي في يونكس (بالثواني)
28            long seconds = Long.parseLong(timestamp);
29            Instant instant = Instant.ofEpochSecond(seconds);
30            dateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
31            System.out.println("تم الكشف: الطابع الزمني القياسي في يونكس (بالثواني)");
32        } else {
33            throw new IllegalArgumentException("تنسيق الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.");
34        }
35        
36        // إنشاء مُنسق بناءً على التنسيق المطلوب
37        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
38            use12Hour ? "EEEE, MMMM d, yyyy h:mm:ss a" : "EEEE, MMMM d, yyyy HH:mm:ss"
39        );
40        
41        // تنسيق التاريخ
42        return dateTime.format(formatter);
43    }
44    
45    public static void main(String[] args) {
46        try {
47            // الطابع الزمني القياسي في يونكس (10 أرقام)
48            System.out.println(convertTimestamp("1609459200", false));
49            
50            // دقة الملي ثانية (13 رقمًا)
51            System.out.println(convertTimestamp("1609459200000", false));
52            
53            // دقة الميكروثانية (16 رقمًا)
54            System.out.println(convertTimestamp("1609459200000000", true));
55        } catch (IllegalArgumentException e) {
56            System.err.println(e.getMessage());
57        }
58    }
59}
60

1// تحويل الطابع الزمني في C# مع اكتشاف تنسيق تلقائي
2using System;
3
4class TimestampConverter
5{
6    public static string ConvertTimestamp(string timestamp, bool use12Hour)
7    {
8        // قم بتقليم الإدخال
9        timestamp = timestamp.Trim();
10        
11        // اكتشاف تنسيق الطابع الزمني بناءً على طول الرقم
12        DateTime dateTime;
13        if (timestamp.Length == 16)
14        {
15            // دقة الميكروثانية (قسم على 1,000,000 للحصول على الثواني)
16            if (!double.TryParse(timestamp, out double microseconds))
17                throw new ArgumentException("تنسيق الطابع الزمني غير صالح");
18                
19            // تحويل الميكروثواني إلى DateTime
20            dateTime = DateTimeOffset.FromUnixTimeSeconds(0).DateTime.AddSeconds(microseconds / 1000000);
21            Console.WriteLine("تم الكشف: الطابع الزمني بدقة الميكروثانية");
22        }
23        else if (timestamp.Length == 13)
24        {
25            // دقة الملي ثانية
26            if (!long.TryParse(timestamp, out long milliseconds))
27                throw new ArgumentException("تنسيق الطابع الزمني غير صالح");
28                
29            dateTime = DateTimeOffset.FromUnixTimeMilliseconds(milliseconds).DateTime;
30            Console.WriteLine("تم الكشف: الطابع الزمني بدقة الملي ثانية");
31        }
32        else if (timestamp.Length == 10)
33        {
34            // الطابع الزمني القياسي في يونكس (بالثواني)
35            if (!long.TryParse(timestamp, out long seconds))
36                throw new ArgumentException("تنسيق الطابع الزمني غير صالح");
37                
38            dateTime = DateTimeOffset.FromUnixTimeSeconds(seconds).DateTime;
39            Console.WriteLine("تم الكشف: الطابع الزمني القياسي في يونكس (بالثواني)");
40        }
41        else
42        {
43            throw new ArgumentException("تنسيق الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.");
44        }
45        
46        // تنسيق السلسلة بناءً على تفضيل 12 ساعة أو 24 ساعة
47        string formatString = use12Hour 
48            ? "dddd, MMMM d, yyyy h:mm:ss tt"  // تنسيق 12 ساعة مع AM/PM
49            : "dddd, MMMM d, yyyy HH:mm:ss";   // تنسيق 24 ساعة
50        
51        // إرجاع سلسلة التاريخ المنسقة
52        return dateTime.ToString(formatString);
53    }
54    
55    static void Main()
56    {
57        try
58        {
59            // الطابع الزمني القياسي في يونكس (10 أرقام)
60            Console.WriteLine(ConvertTimestamp("1609459200", false));
61            
62            // دقة الملي ثانية (13 رقمًا)
63            Console.WriteLine(ConvertTimestamp("1609459200000", false));
64            
65            // دقة الميكروثانية (16 رقمًا)
66            Console.WriteLine(ConvertTimestamp("1609459200000000", true));
67        }
68        catch (ArgumentException e)
69        {
70            Console.WriteLine(e.Message);
71        }
72    }
73}
74

التعامل مع الحالات الحدية

عند العمل مع الطوابع الزمنية في يونكس بمختلف الدقات، من المهم التعامل مع الحالات الحدية بشكل صحيح. إليك مثال يوضح التعامل الشامل مع الحالات الحدية:

1// التعامل الشامل مع الحالات الحدية في JavaScript للطوابع الزمنية المتعددة
2function safeConvertTimestamp(timestamp, use12Hour = false) {
3  // التحقق من الإدخال
4  if (timestamp === undefined || timestamp === null || timestamp === '') {
5    return "خطأ: الطابع الزمني فارغ أو غير معرف";
6  }
7  
8  // تأكد من أن الطابع الزمني سلسلة للتحقق من الطول
9  const timestampStr = String(timestamp).trim();
10  
11  // تحقق مما إذا كان الطابع الزمني يحتوي على أرقام فقط
12  if (!/^\d+$/.test(timestampStr)) {
13    return "خطأ: يجب أن يحتوي الطابع الزمني على أرقام فقط";
14  }
15  
16  // اكتشاف التنسيق بناءً على الطول
17  let date;
18  try {
19    if (timestampStr.length === 16) {
20      // دقة الميكروثانية
21      const microseconds = Number(timestampStr);
22      date = new Date(microseconds / 1000); // تحويل إلى ملي ثانية
23      console.log("معالجة الطابع الزمني بدقة الميكروثانية (16 رقمًا)");
24      
25      // تحقق من التاريخ غير صالح
26      if (isNaN(date.getTime())) {
27        return "خطأ: الطابع الزمني بدقة الميكروثانية غير صالح";
28      }
29    } else if (timestampStr.length === 13) {
30      // دقة الملي ثانية
31      const milliseconds = Number(timestampStr);
32      date = new Date(milliseconds);
33      console.log("معالجة الطابع الزمني بدقة الملي ثانية (13 رقمًا)");
34      
35      // تحقق من التاريخ غير صالح
36      if (isNaN(date.getTime())) {
37        return "خطأ: الطابع الزمني بدقة الملي ثانية غير صالح";
38      }
39    } else if (timestampStr.length === 10) {
40      // الطابع الزمني القياسي في يونكس (بالثواني)
41      const seconds = Number(timestampStr);
42      date = new Date(seconds * 1000);
43      console.log("معالجة الطابع الزمني القياسي (10 أرقام)");
44      
45      // تحقق من التاريخ غير صالح
46      if (isNaN(date.getTime())) {
47        return "خطأ: الطابع الزمني القياسي غير صالح";
48      }
49      
50      // تحقق من مشكلة Y2K38 (للنظم 32 بت)
51      const maxInt32 = 2147483647; // القيمة القصوى لعدد صحيح موقعة 32 بت
52      if (seconds > maxInt32) {
53        console.warn("تحذير: الطابع الزمني يتجاوز الحد الأقصى لعدد صحيح 32 بت (مشكلة Y2K38)");
54      }
55    } else {
56      return "خطأ: طول الطابع الزمني غير صالح. متوقع 10 أو 13 أو 16 رقمًا.";
57    }
58    
59    // تنسيق التاريخ
60    const options = {
61      year: 'numeric',
62      month: 'long',
63      day: 'numeric',
64      weekday: 'long',
65      hour: use12Hour ? 'numeric' : '2-digit',
66      minute: '2-digit',
67      second: '2-digit',
68      hour12: use12Hour
69    };
70    
71    return date.toLocaleString(undefined, options);
72  } catch (error) {
73    return "خطأ في تحويل الطابع الزمني: " + error.message;
74  }
75}
76
77// اختبار مع حالات حدية مختلفة
78console.log(safeConvertTimestamp("1609459200"));      // القياسي (10 أرقام)
79console.log(safeConvertTimestamp("1609459200000"));   // بالملي ثانية (13 رقمًا)
80console.log(safeConvertTimestamp("1609459200000000")); // بالميكروثانية (16 رقمًا)
81console.log(safeConvertTimestamp("abc123"));          // غير رقمي
82console.log(safeConvertTimestamp("12345"));           // طول غير صالح
83console.log(safeConvertTimestamp("9999999999999999")); // طابع زمني كبير جدًا بالميكروثانية
84console.log(safeConvertTimestamp(""));                // سلسلة فارغة
85

الأسئلة الشائعة

ما هو الطابع الزمني في يونكس؟

الطابع الزمني في يونكس هو عدد الثواني التي مرت منذ 1 يناير 1970 (منتصف الليل UTC/GMT)، دون احتساب الثواني الكبيسة. يوفر تمثيلًا مضغوطًا ومستقلًا عن اللغة للحظة معينة في الزمن.

كيف يعمل اكتشاف تنسيق الطابع الزمني التلقائي؟

يكتشف المحول تنسيق الطابع الزمني تلقائيًا بناءً على عدد الأرقام:

• 10 أرقام: الطابع الزمني القياسي في يونكس (الثواني منذ البداية)
• 13 رقمًا: الطابع الزمني بدقة الملي ثانية
• 16 رقمًا: الطابع الزمني بدقة الميكروثانية

لماذا أحتاج إلى دقة الملي ثانية أو الميكروثانية؟

تعتبر دقة الملي ثانية (13 رقمًا) مفيدة للتطبيقات التي تتطلب توقيتًا أكثر دقة، مثل مراقبة الأداء، وتتبع تفاعلات المستخدم، وبعض التطبيقات المالية. تعتبر دقة الميكروثانية (16 رقمًا) ضرورية للحوسبة عالية الأداء، والتطبيقات العلمية، وأنظمة التداول عالية التردد حيث يكون التوقيت الدقيق أمرًا حاسمًا.

هل يمكنني تحويل التواريخ قبل عام 1970 باستخدام الطوابع الزمنية في يونكس؟

نعم، تُمثل التواريخ قبل 1 يناير 1970 باستخدام الطوابع الزمنية السلبية. ومع ذلك، قد لا تتعامل بعض الأنظمة مع الطوابع الزمنية السلبية بشكل صحيح، لذا من المهم اختبار هذه الوظيفة إذا كنت بحاجة إلى العمل مع تواريخ تاريخية.

ما هي مشكلة عام 2038؟

تحدث مشكلة عام 2038 لأن العديد من الأنظمة تخزن الطوابع الزمنية في يونكس كأعداد صحيحة موقعة 32 بت، والتي يمكن أن تمثل التواريخ فقط حتى 19 يناير 2038 (03:14:07 UTC). بعد هذه النقطة، ستفيض الأعداد الصحيحة، مما قد يؤدي إلى فشل النظام. تستخدم الأنظمة الحديثة بشكل متزايد أعدادًا صحيحة 64 بت لتجنب هذه المشكلة.

كيف أتعامل مع تحويلات المنطقة الزمنية باستخدام الطوابع الزمنية في يونكس؟

تمثل الطوابع الزمنية في يونكس دائمًا في UTC (التوقيت العالمي المنسق). يتطلب التحويل إلى منطقة زمنية معينة تطبيق الإزاحة المناسبة بعد تحويل الطابع الزمني إلى تاريخ. توفر معظم لغات البرمجة وظائف مدمجة للتعامل مع تحويلات المنطقة الزمنية.

ما الفرق بين الوقت في يونكس وISO 8601؟

الوقت في يونكس هو تمثيل عددي (الثواني منذ البداية)، بينما ISO 8601 هو تنسيق سلسلة (مثل "2021-01-01T00:00:00Z"). يعتبر الوقت في يونكس أكثر إحكامًا وأسهل للاستخدام في الحسابات، بينما ISO 8601 أكثر قابلية للقراءة البشرية ووصفًا ذاتيًا.

ما مدى دقة الطوابع الزمنية في يونكس؟

لدى الطوابع الزمنية القياسية في يونكس دقة على مستوى الثواني. توفر الطوابع الزمنية بدقة الملي ثانية (13 رقمًا) دقة أكبر بمقدار 1000 مرة، وتوفر الطوابع الزمنية بدقة الميكروثانية (16 رقمًا) دقة أكبر بمقدار 1,000,000 من الثانية.

هل تأخذ الطوابع الزمنية في يونكس في الاعتبار الثواني الكبيسة؟

لا، لا يأخذ الوقت في يونكس في الاعتبار الثواني الكبيسة، التي تُضاف أحيانًا إلى UTC لتعويض الدوران غير المنتظم للأرض. وهذا يعني أن الوقت في يونكس ليس متزامنًا بدقة مع الوقت الفلكي.

هل يمكنني استخدام الطوابع الزمنية في يونكس لجدولة الأحداث المستقبلية؟

نعم، تُستخدم الطوابع الزمنية في يونكس على نطاق واسع للجدولة. ومع ذلك، بالنسبة للتواريخ المستقبلية البعيدة جدًا، كن على دراية بالقيود المحتملة مثل مشكلة عام 2038 للنظم 32 بت وتعقيدات تغييرات المنطقة الزمنية وانتقالات توقيت التوفير الصيفي.

المراجع

1. "وقت يونكس." ويكيبيديا، مؤسسة ويكيميديا، https://en.wikipedia.org/wiki/Unix_time

2. "مشكلة عام 2038." ويكيبيديا، مؤسسة ويكيميديا، https://en.wikipedia.org/wiki/Year_2038_problem

3. أولسون، آرثر ديفيد. "تعقيدات الوقت التقويمي." مجموعة Open Group، https://www.usenix.org/legacy/events/usenix01/full_papers/olson/olson.pdf

4. "ISO 8601." ويكيبيديا، مؤسسة ويكيميديا، https://en.wikipedia.org/wiki/ISO_8601

5. "RFC 3339: التاريخ والوقت على الإنترنت: الطوابع الزمنية." مجموعة هندسة الإنترنت (IETF)، https://tools.ietf.org/html/rfc3339

6. كيرنيغان، بريان وريتشي، دينيس م. "لغة البرمجة C." برينتيس هول، 1988.

7. "التوقيت الدقيق في الحوسبة عالية الأداء." استعراضات الحوسبة ACM، https://dl.acm.org/doi/10.1145/3232678

8. "تمثيل الوقت في الأنظمة المالية." مجلة التكنولوجيا المالية، https://www.fintech-journal.com/time-representation

جرب محول الطوابع الزمنية لدينا الآن لتحويل الطوابع الزمنية في يونكس بسهولة إلى تواريخ قابلة للقراءة. سواء كنت تعمل مع الطوابع الزمنية القياسية، أو بدقة الملي ثانية، أو بدقة الميكروثانية، يكتشف أداتنا التنسيق تلقائيًا ويوفر تحويلات دقيقة.