NSDate का उपयोग करके सप्ताह का दिन प्राप्त करें

Question 1

मैंने "YYYY-MM-DD" फ़ॉर्म में एक स्ट्रिंग लेने का एक तरीका बनाया है और एक ऐसा इंट बाहर निकाल दिया है जो उस सप्ताह के संबंध में तिथियों की स्थिति का प्रतिनिधित्व करता है (भले ही यह महीनों के बीच ओवरलैप हो)। इसलिए जैसे रविवार = 1 सोमवार = 2 और इसी तरह।

यहाँ मेरा कोड है:

    func getDayOfWeek(today:String)->Int{

    var formatter:NSDateFormatter = NSDateFormatter()
    formatter.dateFormat = "YYYY-MM-DD"
    var todayDate:NSDate = formatter.dateFromString(today)!
    var myCalendar:NSCalendar = NSCalendar(calendarIdentifier: NSGregorianCalendar)
    var myComponents = myCalendar.components(NSCalendarUnit.WeekdayOrdinalCalendarUnit, fromDate: todayDate)
    var weekDay = myComponents.weekdayOrdinal
    return weekDay
}

मुझे पता है कि NSCalendarUnit.WeekdayOrdinalCalendarयह गलत है, लेकिन मैंने कोशिश की है कि मुझे सबसे तार्किक संयोजन लगता है। और myComponents.weekdayOrdinalजैसे इस्तेमाल किए गए mycomponents.dayया .weekday।

यहाँ मेरा उपयोग करने के विकल्प हैं:

static var EraCalendarUnit: NSCalendarUnit { get }
static var YearCalendarUnit: NSCalendarUnit { get }
static var MonthCalendarUnit: NSCalendarUnit { get }
static var DayCalendarUnit: NSCalendarUnit { get }
static var HourCalendarUnit: NSCalendarUnit { get }
static var MinuteCalendarUnit: NSCalendarUnit { get }
static var SecondCalendarUnit: NSCalendarUnit { get }
static var WeekCalendarUnit: NSCalendarUnit { get }
static var WeekdayCalendarUnit: NSCalendarUnit { get }
static var WeekdayOrdinalCalendarUnit: NSCalendarUnit { get }
static var QuarterCalendarUnit: NSCalendarUnit { get }
static var WeekOfMonthCalendarUnit: NSCalendarUnit { get }
static var WeekOfYearCalendarUnit: NSCalendarUnit { get }
static var YearForWeekOfYearCalendarUnit: NSCalendarUnit { get }
static var CalendarCalendarUnit: NSCalendarUnit { get }
static var TimeZoneCalendarUnit: NSCalendarUnit { get }

यह मेरे लिए स्पष्ट नहीं है क्योंकि कोई DayOfWeekUnit विकल्प (या कुछ समान) नहीं है।

Question 2

आप जिस चीज की तलाश कर रहे हैं (यदि मैं प्रश्न को सही ढंग से समझता हूं) है NSCalendarUnit.CalendarUnitWeekday। की संगत संपत्ति NSDateComponentsहै weekday।

ध्यान दें कि आपका दिनांक प्रारूप गलत है (पूर्ण विनिर्देश यहां पाया जा सकता है: http://unicode.org/reports/tr35/tr35-6.html )।

फ़ंक्शन को थोड़ा सरल किया जा सकता है, स्वत: प्रकार के इंजेक्शन का उपयोग करके, आप चर का उपयोग बहुत अधिक करते हैं जहां स्थिरांक पर्याप्त हैं। इसके अलावा, फ़ंक्शन को एक वैकल्पिक वापस करना चाहिए जो nil अमान्य इनपुट स्ट्रिंग के लिए है।

स्विफ्ट 3 और बाद के लिए अपडेटेड कोड :

func getDayOfWeek(_ today:String) -> Int? {
    let formatter  = DateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    guard let todayDate = formatter.date(from: today) else { return nil }
    let myCalendar = Calendar(identifier: .gregorian)
    let weekDay = myCalendar.component(.weekday, from: todayDate)
    return weekDay
}

उदाहरण:

if let weekday = getDayOfWeek("2014-08-27") {
    print(weekday)
} else {
    print("bad input")
}

स्विफ्ट 2 के लिए मूल उत्तर :

func getDayOfWeek(today:String)->Int? {

    let formatter  = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
        let weekDay = myComponents.weekday
        return weekDay
    } else {
        return nil
    }
}

Question 3

स्विफ्ट 3 और 4

सप्ताह की संख्या के दिन को पुनः प्राप्त करना स्विफ्ट 3 में नाटकीय रूप से सरल है क्योंकि DateComponentsअब वैकल्पिक नहीं है। यहाँ यह एक विस्तार के रूप में है:

extension Date {
    func dayNumberOfWeek() -> Int? {
        return Calendar.current.dateComponents([.weekday], from: self).weekday 
    }
}

// returns an integer from 1 - 7, with 1 being Sunday and 7 being Saturday
print(Date().dayNumberOfWeek()!) // 4

यदि आप सप्ताह के दिन का लिखित, स्थानीय संस्करण खोज रहे हैं:

extension Date {
    func dayOfWeek() -> String? {
        let dateFormatter = DateFormatter()
        dateFormatter.dateFormat = "EEEE"
        return dateFormatter.string(from: self).capitalized 
        // or use capitalized(with: locale) if you want
    }
}

print(Date().dayOfWeek()!) // Wednesday

Question 4

यदि आप पूर्ण "रविवार", "सोमवार", "मंगलवार", "बुधवार" आदि चाहते हैं।

संपादित करें: वहाँ वास्तव में एक प्रारूप है जो स्थानीयकृत दिन के नाम देता है:

extension NSDate {
    func dayOfTheWeek() -> String? {        
        let dateFormatter = NSDateFormatter()
        dateFormatter.dateFormat = "EEEE"
        return dateFormatter.stringFromDate(self)
    }
}

मेरा पिछला समाधान (केवल अंग्रेजी के लिए):

extension NSDate {

    func dayOfTheWeek() -> String? {
        let weekdays = [
            "Sunday",
            "Monday",
            "Tuesday",
            "Wednesday",
            "Thursday",
            "Friday",
            "Saturday"
        ]

        let calendar: NSCalendar = NSCalendar.currentCalendar()
        let components: NSDateComponents = calendar.components(.Weekday, fromDate: self)
        return weekdays[components.weekday - 1]
    }
}

आपको कैलेंडर और घटकों को अनचेक करने की आवश्यकता नहीं है, वे नींव के ढांचे द्वारा गारंटीकृत हैं।

उपयोग:

print(myDate.dayOfTheWeek())

Question 5

सरल उत्तर (स्विफ्ट 3):

Calendar.current.component(.weekday, from: Date())

Question 6

मेरे मामले में मैं प्रत्येक दिन के लिए तीन पत्र स्ट्रिंग के बाद था। मैंने @Martin R के फंक्शन को इस प्रकार संशोधित किया है:

func getDayOfWeekString(today:String)->String? {
    let formatter  = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
        let weekDay = myComponents.weekday
        switch weekDay {
        case 1:
            return "Sun"
        case 2:
            return "Mon"
        case 3:
            return "Tue"
        case 4:
            return "Wed"
        case 5:
            return "Thu"
        case 6:
            return "Fri"
        case 7:
            return "Sat"
        default:
            print("Error fetching days")
            return "Day"
        }
    } else {
        return nil
    }
}

Question 7

एक आसान तरीका है। बस अपनी स्ट्रिंग तिथि निम्नलिखित समारोह में दें, यह आपको दिन का नाम देगा :)

func getDayNameBy(stringDate: String) -> String
    {
        let df  = NSDateFormatter()
        df.dateFormat = "YYYY-MM-dd"
        let date = df.dateFromString(stringDate)!
        df.dateFormat = "EEEE"
        return df.stringFromDate(date);
    }

Question 8

extension Date {

var weekdayName: String {
    let formatter = DateFormatter(); formatter.dateFormat = "E"
    return formatter.string(from: self as Date)
}

var weekdayNameFull: String {
    let formatter = DateFormatter(); formatter.dateFormat = "EEEE"
    return formatter.string(from: self as Date)
}
var monthName: String {
    let formatter = DateFormatter(); formatter.dateFormat = "MMM"
    return formatter.string(from: self as Date)
}
var OnlyYear: String {
    let formatter = DateFormatter(); formatter.dateFormat = "YYYY"
    return formatter.string(from: self as Date)
}
var period: String {
    let formatter = DateFormatter(); formatter.dateFormat = "a"
    return formatter.string(from: self as Date)
}
var timeOnly: String {
    let formatter = DateFormatter(); formatter.dateFormat = "hh : mm"
    return formatter.string(from: self as Date)
}
var timeWithPeriod: String {
    let formatter = DateFormatter(); formatter.dateFormat = "hh : mm a"
    return formatter.string(from: self as Date)
}

var DatewithMonth: String {
    let formatter = DateFormatter(); formatter.dateStyle = .medium ;        return formatter.string(from: self as Date)
}
}

सप्ताह के दिन का उपयोग करें = दिनांक ()

Question 9

स्विफ्ट 3 तिथि विस्तार

extension Date {
    var weekdayOrdinal: Int {
        return Calendar.current.component(.weekday, from: self)
    }
}

Question 10

आप इस तालिका का उपयोग कर सकते हैं date_formats विभिन्न स्वरूपों के लिए अपनी तिथि परिवर्तित करने के लिए। मेरा सबसे छोटा कोड:

func getDayOfWeek(today: String) -> Int{
    let formatter:NSDateFormatter = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    let todayDate = formatter.dateFromString(today)
    formatter.dateFormat = "e" // "eeee" -> Friday
    let weekDay = formatter.stringFromDate(todayDate!)
    return Int(weekDay)!
}
getDayOfWeek("2015-12-18") // 6

Question 11

स्विफ्ट 5 - सप्ताह का दिन

    extension Date {

        var dayofTheWeek: String {
             let dayNumber = Calendar.current.component(.weekday, from: self)
             // day number starts from 1 but array count from 0
             return daysOfTheWeek[dayNumber - 1]
        }

        private var daysOfTheWeek: [String] {
             return  ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
        }
     }

फेटी के उत्तर के आधार पर तिथि विस्तार

Question 12

व्यावहारिक समाधान ...

ज्ञात हो कि परिणाम पूर्णांक सात के माध्यम से एक होते हैं।

(छह के माध्यम से शून्य नहीं।)

let trivialDayStringsORDINAL = ["", "SUN","MON","TUE","WED","THU","FRI","SAT"]
// note that zero is not used

और फिर ...

let dow = Calendar.current.component(.weekday, from: someDate)
print( trivialDayStringsORDINAL[dow] )

Question 13

यहां पहले से ही बहुत सारे उत्तर हैं, लेकिन मुझे लगता है कि सही Calendarएपीआई का उपयोग करके ऐसा करने का एक और, बेहतर, बेहतर तरीका है ।

मैं सुझाव देता हूं कि सप्ताह के दिन weekdaySymbolsको Calendar( डॉक्स ) की संपत्ति का विस्तार में उपयोग करते हुए Date:

extension Date {

    /// Returns the day of the week as a `String`, e.g. "Monday"
    var dayOfWeek: String {
        let calendar = Calendar.autoupdatingCurrent
        return calendar.weekdaySymbols[calendar.component(.weekday, from: self) - 1]
    }
}

इसके लिए Dateपहले एक इनिशियलाइज़िंग की आवश्यकता होती है , जिसे मैं एक रिवाज़ का उपयोग करके करूँगा DateFormatter:

extension DateFormatter {

    /// returns a `DateFormatter` with the format "yyyy-MM-dd".
    static var standardDate: DateFormatter {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        return formatter
    }
}

यह तब के साथ बुलाया जा सकता है:

DateFormatter.standardDate.date(from: "2018-09-18")!.dayOfWeek

मुझे यह क्यों पसंद है:

dayOfWeek उपयोगकर्ता के कैलेंडर का उपयोग करने के लिए समय क्षेत्रों के बारे में परवाह करने की आवश्यकता नहीं है, यहां कुछ अन्य समाधान गलत दिन दिखाएंगे क्योंकि समय क्षेत्र पर विचार नहीं किया जाता है।
यह बहुत संभावना है कि आपको अन्य स्थानों पर एक ही प्रारूप में तिथियों का उपयोग करने की आवश्यकता होगी इसलिए पुन: प्रयोज्य क्यों न बनाएं DateFormatterऔर इसके बजाय इसका उपयोग करें?
weekdaySymbols आपके लिए स्थानीयकृत है।
weekDaySymbolsअन्य विकल्पों जैसे shortWeekdaySymbols"सोम", "मंगल" आदि के साथ प्रतिस्थापित किया जा सकता है ।

कृपया ध्यान दें: यह उदाहरण DateFormatterभी समय क्षेत्र या स्थानों पर विचार नहीं करता है, आपको उन्हें अपनी आवश्यकता के लिए सेट करना होगा। यदि तिथियां हमेशा सटीक होती हैं, तो समय क्षेत्र निर्धारित करने पर विचार करें TimeZone(secondsFromGMT: 0)।

Question 14

मैंने तारीख से कुछ और तार की आवश्यकता समाप्त की, जिसमें सप्ताह की तारीख (जैसे "5 वें") और वर्ष का महीना (जैसे अगस्त) शामिल है। नीचे सभी तीन कार्य हैं जो मैंने @Martin R के फ़ंक्शन के आधार पर बनाए हैं और 3 चार तार वापस करने के लिए संशोधित किए हैं:

//Date String Helper Functions
func getDayOfWeek(today:String)->String? {
    let formatter  = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
        let weekDay = myComponents.weekday
        switch weekDay {
        case 1:
            return "Sun"
        case 2:
            return "Mon"
        case 3:
            return "Tue"
        case 4:
            return "Wed"
        case 5:
            return "Thu"
        case 6:
            return "Fri"
        case 7:
            return "Sat"
        default:
            print("Error fetching days")
            return "Day"
        }
    } else {
        return nil
    }
}

func getDateOfMonth(today:String)->String? {
    let formatter  = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Day, fromDate: todayDate)
        let weekDay = myComponents.day
        switch weekDay {
        case 1:
            return "1st"
        case 2:
            return "2nd"
        case 3:
            return "3rd"
        case 4:
            return "4th"
        case 5:
            return "5th"
        case 6:
            return "6th"
        case 7:
            return "7th"
        case 8:
            return "8th"
        case 9:
            return "9th"
        case 10:
            return "10th"
        case 11:
            return "11th"
        case 12:
            return "12th"
        case 13:
            return "13th"
        case 14:
            return "14th"
        case 15:
            return "15th"
        case 16:
            return "16th"
        case 17:
            return "17th"
        case 18:
            return "18th"
        case 19:
            return "19th"
        case 20:
            return "20th"
        case 21:
            return "21st"
        case 22:
            return "22nd"
        case 23:
            return "23rd"
        case 24:
            return "24th"
        case 25:
            return "25th"
        case 26:
            return "26th"
        case 27:
            return "27th"
        case 28:
            return "28th"
        case 29:
            return "29th"
        case 30:
            return "30th"
        case 31:
            return "31st"
        default:
            print("Error fetching Date Of Month")
            return "Day"
        }
    } else {
        return nil
    }
}

func getMonthOfYear(today:String)->String? {
    let formatter  = NSDateFormatter()
    formatter.dateFormat = "yyyy-MM-dd"
    if let todayDate = formatter.dateFromString(today) {
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
        let myComponents = myCalendar.components(.Month, fromDate: todayDate)
        let month = myComponents.month
        switch month {
        case 1:
            return "Jan"
        case 2:
            return "Feb"
        case 3:
            return "Mar"
        case 4:
            return "Apr"
        case 5:
            return "May"
        case 6:
            return "Jun"
        case 7:
            return "Jul"
        case 8:
            return "Aug"
        case 9:
            return "Sep"
        case 10:
            return "Oct"
        case 11:
            return "Nov"
        case 12:
            return "Dec"
        default:
            print("Error fetching months")
            return "Month"
        }
    } else {
        return nil
    }
}

Question 15

Monday से शुरू होने वाले वर्तमान सप्ताह को पेश करने के लिए SWIFT 2.0 कोड।

@ आईबीए फन शो (प्रेषक: AnyObject) {

   // Getting Days of week corresponding to their dateFormat

    let calendar = NSCalendar.currentCalendar()
    let dayInt: Int!
    var weekDate: [String] = []
    var i = 2

    print("Dates corresponding to days are")
    while((dayInt - dayInt) + i < 9)
    {
        let weekFirstDate = calendar.dateByAddingUnit(.Day, value: (-dayInt+i), toDate: NSDate(), options: [])
        let dateFormatter = NSDateFormatter()
        dateFormatter.dateFormat = "EEEE dd MMMM"
        let dayOfWeekString = dateFormatter.stringFromDate(weekFirstDate!)
        weekDate.append(dayOfWeekString)
        i++
    }
    for i in weekDate
    {
        print(i) //Printing the day stored in array
    }
}

// function to get week day
func getDayOfWeek(today:String)->Int {

    let formatter  = NSDateFormatter()
    formatter.dateFormat = "MMM-dd-yyyy"
    let todayDate = formatter.dateFromString(today)!
    let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
    let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
    let weekDay = myComponents.weekday
    return weekDay
}


@IBAction func DateTitle(sender: AnyObject) {


    // Getting currentDate and weekDay corresponding to it
    let currentDate = NSDate()
    let dateFormatter = NSDateFormatter()
    dateFormatter.dateFormat = "MMM-dd-yyyy"
    let dayOfWeekStrings = dateFormatter.stringFromDate(currentDate)
    dayInt = getDayOfWeek(dayOfWeekStrings)

}

Question 16

यह कोड पूरे चालू सप्ताह का पता लगाना है। यह स्विफ्ट 2.0 में लिखा गया है:

var i = 2
var weekday: [String] = []
var weekdate: [String] = []
var weekmonth: [String] = []

@IBAction func buttonaction(sender: AnyObject) {

    let currentDate = NSDate()
    let dateFormatter = NSDateFormatter()
    dateFormatter.dateFormat = "MMM-dd-yyyy"
    let dayOfWeekStrings = dateFormatter.stringFromDate(currentDate)
    let weekdays = getDayOfWeek(dayOfWeekStrings)
    let calendar = NSCalendar.currentCalendar()

    while((weekdays - weekdays) + i < 9)
    {
        let weekFirstDate = calendar.dateByAddingUnit(.Day, value: (-weekdays+i), toDate: NSDate(), options: [])

        let dayFormatter = NSDateFormatter()
        dayFormatter.dateFormat = "EEEE"
        let dayOfWeekString = dayFormatter.stringFromDate(weekFirstDate!)
        weekday.append(dayOfWeekString)

        let dateFormatter = NSDateFormatter()
        dateFormatter.dateFormat = "dd"
        let dateOfWeekString = dateFormatter.stringFromDate(weekFirstDate!)
        weekdate.append(dateOfWeekString)

        let monthFormatter = NSDateFormatter()
        monthFormatter.dateFormat = "MMMM"
        let monthOfWeekString = monthFormatter.stringFromDate(weekFirstDate!)
        weekmonth.append(monthOfWeekString)

        i++
    }

    for(var j = 0; j<7 ; j++)
    {
    let day = weekday[j]
    let date = weekdate[j]
    let month = weekmonth[j]
    var wholeweek = date + "-" + month + "(" + day + ")"
    print(wholeweek)
    }

}

func getDayOfWeek(today:String)->Int {
    let formatter  = NSDateFormatter()
    formatter.dateFormat = "MMM-dd-yyyy"
    let todayDate = formatter.dateFromString(today)!
    let myCalendar = NSCalendar(calendarIdentifier: NSCalendarIdentifierGregorian)!
    let myComponents = myCalendar.components(.Weekday, fromDate: todayDate)
    let daynumber = myComponents.weekday
    return daynumber
}

आउटपुट इस तरह होगा:

14March (सोमवार) 15March (मंगलवार) 16March (बुधवार) 17March (गुरुवार) 18March (शुक्रवार) 19March (शनिवार) 20March (रविवार)

Question 17

स्विफ्ट 3: Xcode 8 हेल्पर फंक्शन:

func getDayOfWeek(fromDate date: Date) -> String? {
    let cal = Calendar(identifier: .gregorian)
    let dayOfWeek = cal.component(.weekday, from: date)
    switch dayOfWeek {
     case 1:
        return "Sunday"
    case 2:
        return "Monday"
    case 3:
        return "Tuesday"
    case 4:
        return "Wednesday"
    case 5:
        return "Thursday"
    case 6:
        return "Friday"
    case 7:
        return "Saturday"
    default:
        return nil
    }
}

Question 18

Swift4 के लिए स्ट्रिंग से कार्यदिवस प्राप्त करने के लिए

   func getDayOfWeek(today:String)->Int {
        let formatter  = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        let todayDate = formatter.date(from: today)!
        let myCalendar = NSCalendar(calendarIdentifier: NSCalendar.Identifier.gregorian)!
        let myComponents = myCalendar.components(NSCalendar.Unit.weekday, from: todayDate)
        let weekDay = myComponents.weekday
        return weekDay!
    }

let weekday = getDayOfWeek(today: "2018-10-10")
print(weekday) // 4