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

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

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

حول المنطقة الزمنية

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

المبدأ الأساسي للمناطق الزمنية هو تقسيم الأرض إلى 24 منطقة. تختلف كل منطقة زمنية عمومًا بساعة واحدة عن المنطقة المجاورة لها. المرجع الرئيسي للمناطق الزمنية هو توقيت غرينتش (GMT) أو التوقيت العالمي المنسق (UTC)، والذي يقع عند خط طول درجة الصفر الذي يمر عبر غرينتش، إنجلترا.

الرسم التوضيحي لهيليريك من ويكيميديا ​​​​كومنز

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

التعامل مع المنطقة الزمنية على جانب الخادم

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

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

• كيفية حفظ التاريخ في قاعدة البيانات
• تحويل التوقيت المحلي للمستخدم
• الاختبار والتحقق

كيفية حفظ التاريخ في قاعدة البيانات

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

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

للتغلب على ذلك، فإن أفضل الممارسات هي تخزين أوقات المعاملات في المنطقة الزمنية UTC (التوقيت العالمي المنسق) والتي تعد المعيار الزمني الأساسي للساعات وإعدادات الوقت. هنا هو تطبيق الوقت على UTC.

package main

import (
    "fmt"
    "time"
)

func main() {

    now := time.Now()
    fmt.Printf("Local time: %s\n", now)

    nowInUTC := now.UTC()
    fmt.Printf("UTC time: %s\n", nowInUTC)

}

دعونا نرى معنى الكود أعلاه.

أولاً، في سطر الكود now := time.Now()، يستخدم هذا السطر وظيفة Now() من حزمة time للحصول على الوقت الحالي بناءً على المنطقة الزمنية المحلية للنظام. يتم تخزين النتيجة في المتغير الحالي.

ثم، في سطر nowInUTC := now.UTC()، هنا نقوم بتحويل التوقيت المحلي (الآن) إلى وقت UTC باستخدام طريقة UTC(). يتم تخزين النتائج في متغير جديد الآنInUTC ويمكن تخزينها هذه المرة على الخادم، حيث من المؤمل أن يتمكن المطورون من تجنب الغموض والأخطاء التي قد تنشأ بسبب اختلافات المنطقة الزمنية بين الخوادم والمستخدمين في مناطق مختلفة بمناطق زمنية مختلفة.

إليك النتائج إذا قمنا بتشغيل الكود أعلاه:

ولكن هذا ليس دائمًا الحل الأفضل الذي يجب عليك استخدامه. قد تكون هناك بعض النقاط التي يمكنك وضعها في الاعتبار في حالات استخدام معينة، إحداها هل صحيح أن مستخدمينا يأتون من مناطق زمنية مختلفة؟ إذا لم يكن ذلك ممكنًا، فربما يؤدي تخزين الوقت بالتوقيت العالمي المنسق (UTC) إلى إضافة تعقيد إلى التعليمات البرمجية الخاصة بك.

تغيير الوقت إلى لغة المستخدم

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

النهج الذي أتبعه هو أن جانب الخادم يطلب دائمًا من العميل إرسال المنطقة الزمنية من جانب المستخدم. يمكن القيام بذلك على جانب الطلب حيث يرسل العميل رأسًا بالمنطقة الزمنية الرئيسية ويحتوي على قيمة المنطقة الزمنية للمستخدم. على سبيل المثال، لدى إندونيسيا 3 أقسام زمنية للمناطق الزمنية، وهي WIT(9)، WITA(8)، WIB(7). حيث يكون لكل منطقة فرق ساعة واحدة. إذا قمنا سابقًا على خادمنا بتخزين التوقيت العالمي المنسق عند الساعة 00.00، فمن جانب WIT كان عند الساعة 09.00، ومن جانب WITA كان عند الساعة 08.00 وWIB عند الساعة 07.00.

إليك مثال على الكود للتعامل مع الحالة أعلاه:

package main

import (
    "fmt"
    "time"
)

func ParseTimezoneFromString(tz string) *time.Location {

    if len(tz) > 0 {

        t, err := time.Parse("2006 -07:00", fmt.Sprintf("2007 %s", tz))

        if err != nil {

            panic(err)

        } else {

            return t.Location()
        }
    }

    return time.Now().Location()
}

func main() {

    timeServerInUTC := "2024-08-04 00:00:00"
    nowInUTC, err := time.Parse("2006-01-02 15:04:05", timeServerInUTC)
    if err != nil {
        panic(err)
    }

    fmt.Printf("UTC time: %s\n", nowInUTC)

    witLocation := ParseTimezoneFromString(" 09:00")

    nowInWIT := nowInUTC.In(witLocation)
    fmt.Printf("WIT time: %s\n", nowInWIT)

    witaLocation := ParseTimezoneFromString(" 08:00")

    nowInWITA := nowInUTC.In(witaLocation)
    fmt.Printf("WITA time: %s\n", nowInWITA)

    wibLocation := ParseTimezoneFromString(" 07:00")

    nowInWIB := nowInUTC.In(wibLocation)
    fmt.Printf("WIB time: %s\n", nowInWIB)

}

الائتمان ل dikac لإنشاء هذه الوظيفة ParseTimezoneFromString

دعونا نفهم معنى الكود أعلاه:

أولاً، نقوم بإنشاء وظيفة ParseTimezoneFromString، حيث يتم استخدام هذه الوظيفة للعثور على الموقع الزمني بناءً على الوسيطة tz أو المنطقة الزمنية لموقع المستخدم المحدد. إذا كانت قيمة السلسلة tz صالحة، فسنقوم بتحويل المنطقة الزمنية للسلسلة باستخدام الدالة time.Parse لتحويل السلسلة إلى كائن زمني، ثم نستخرج الموقع (المنطقة الزمنية) من هذا الكائن. ونتعامل أيضًا مع ما إذا كانت السلسلة فارغة أو فشل التحليل، فتقوم الدالة بإرجاع المنطقة الزمنية المحلية للنظام.

func ParseTimezoneFromString(tz string) *time.Location {

    if len(tz) > 0 {

        t, err := time.Parse("2006 -07:00", fmt.Sprintf("2007 %s", tz))

        if err != nil {

            panic(err)

        } else {

            return t.Location()
        }
    }

    return time.Now().Location()
}

بعد ذلك نحدد أيضًا بيانات الوقت بتنسيق السلسلة التالي:

timeServerInUTC := "2024-08-04 00:00:00"

nowInUTC, err := time.Parse("2006-01-02 15:04:05", timeServerInUTC)
if err != nil {
    panic(err)
}

يمكنك اعتبار هذا بمثابة بيانات التوقيت التي نحصل عليها من الخادم. وتحليلها إلى كائن زمني.

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

يمكننا استخدام الموقع الذي نحصل عليه من وظيفة ParseTimezoneFromString لتحويل أو تحويل الوقت الذي نحصل عليه من الخادم إلى التوقيت المحلي للمستخدم. يمكننا القيام بذلك باستخدام وظيفة In المضمنة أيضًا في الحزمة الزمنية والتي يمكننا رؤيتها في مقتطف الكود التالي:

nowInWIT := nowInUTC.In(witLocation)
nowInWITA := nowInUTC.In(witaLocation)
nowInWIB := nowInUTC.In(wibLocation)

إذا قمنا بتشغيله، فسنحصل على الوقت الذي يتوافق مع موقع المنطقة الزمنية التي حددناها.

الاختبار والتحقق من الصحة

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

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

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

خاتمة

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

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

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

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

شكرًا لك على القراءة، وآمل أن يكون هذا المقال مفيدًا في رحلة التطوير الخاصة بك. دعونا نواصل التعلم والتحسن معًا! ?

مراجع القراءة

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