Holen Sie sich den Wochentag mit NSDate

89

Ich habe eine Methode erstellt, die eine Zeichenfolge in der Form "JJJJ-MM-TT" aufnehmen und ein Int ausspucken soll, das die Datumsposition in Bezug auf die Woche darstellt, in der sie sich befindet (unabhängig davon, ob sie sich zwischen Monaten überschneidet). Also zB Sonntag = 1 Montag = 2 und so weiter.

Hier ist mein Code:

    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
}

Ich weiß, dass NSCalendarUnit.WeekdayOrdinalCalendardas falsch ist, aber ich habe versucht, die logischsten Kombinationen zu finden. Und habe auch mit myComponents.weekdayOrdinalzB gebrauchtem mycomponents.dayoder herumgespielt .weekday.

Hier sind meine Optionen für die Verwendung:

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 }

Es ist mir nicht klar, da es keine DayOfWeekUnit-Option (oder ähnliches) gibt.

swift  nsdate  nscalendar 
— Boidkan
quelle
1
Informationen zum Formatieren von Zeichen finden Sie unter: Formatierungsdaten und -zeiten auf der Intensivstation .
— Zaph
— Suhaib
1
@Suhaib Wenn Sie sich meine Tags ansehen, heißt es Swift nicht Objective-C. Außerdem ist der Code in Swift 2.
— Boidkan
Versuchen Sie die folgenden "EEEE" in Ihrem Datumsformatierer
— Alexandros

Antworten:

118

Was Sie suchen (wenn ich die Frage richtig verstehe) ist NSCalendarUnit.CalendarUnitWeekday. Die entsprechende Eigenschaft von NSDateComponentsist weekday.

Beachten Sie auch, dass Ihr Datumsformat falsch ist (die vollständige Spezifikation finden Sie hier: http://unicode.org/reports/tr35/tr35-6.html ).

Die Funktion kann mithilfe der automatischen Typinferenz leicht vereinfacht werden. Außerdem verwenden Sie häufig Variablen, bei denen Konstanten ausreichend sind. Außerdem sollte die Funktion eine Option zurückgeben, die nil für eine ungültige Eingabezeichenfolge gilt.

Aktualisierter Code für Swift 3 und höher:

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
}

Beispiel:

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

Ursprüngliche Antwort für Swift 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
    }
}
— Martin R.
quelle
Ja, es war das Format, das mich durcheinander gebracht hat. Ich bekam 2 statt 4, als ich WeekdayCalendarUnit ausprobierte und war sehr verwirrt! Danke für den Link, ich werde es nachlesen.
— Boidkan
1
Ich weiß, dass dies nicht Teil der ursprünglichen Frage ist, aber dies wäre ein guter Ort, um ein optionales Int zurückzugeben, falls das übergebene Datum nicht das richtige Format hat oder in irgendeiner Weise ungültig ist.
— Mike S
1
Sollte es nicht sein func getDayOfWeek(today:String)->Int?. Wenn Sie das optionale Auspacken erzwingen, stürzt es immer noch ab, nicht wahr?
— HAT
1
@ HAS: Du hast vollkommen recht, danke! - In meinem Testfall ist es nicht abgestürzt, da die optionale Zuweisung if let ...auch mit implizit entpackten Optionen funktioniert.
— Martin R
1
Vielen Dank, Marting. Um Ihre Antwort schöner zu machen, können Sie sie bearbeiten, um den Swift 2-Code zu entfernen und den Swift 3-Code beizubehalten. Fügen Sie dann am Ende eine Notiz hinzu, die besagt: "Wenn Sie Code für Swift 2 benötigen, überprüfen Sie die vorherige Bearbeitung" oder so ähnlich
— Suhaib
151

Schnelle 3 & 4

Das Abrufen der Wochentagsnummer wird in Swift 3 erheblich vereinfacht, da dies DateComponentsnicht mehr optional ist. Hier ist es als Erweiterung:

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

Wenn Sie nach der schriftlichen, lokalisierten Version des Wochentags suchen:

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
— Brandonscript
quelle
1
Vielleicht wäre es klarer, wenn Sie aDate.dayOfWeek () unter Usage setzen.
— Boidkan
1
Beachten Sie, dass die Frage lautete, wie der Wochentag aus einer Zeichenfolge in der Form "JJJJ-MM-TT" abgerufen werden kann. Natürlich vereinfacht es, wenn Sie bereits ein NSDate haben.
— Martin R
4
Es ist wahrscheinlich erwähnenswert, dass, wenn Sie es in z. In der Tabellenansicht kann das Scrollen verlangsamt werden, da das Erstellen von DateFormatter sehr kostspielig ist. Wenn Sie es sehr oft verwenden, ist es gut, z. Erstellen Sie eine Instanz und stellen Sie sie während der Berechnung allen Funktionsaufrufen zur Verfügung.
— Vive
Absolut. In diesem Fall wäre sogar ein Array-Handler hilfreich, mit dem Sie die Funktion für ein Datenarray ausführen können.
— Brandonscript
1
Einfacher wäre nur die Antwort von @ david72 unten: Calendar.current.component (.weekday, from: Date ())
— Adam Smaka
37

Wenn Sie den vollen "Sonntag", "Montag", "Dienstag", "Mittwoch" usw. wollen.

BEARBEITEN: Es gibt tatsächlich ein eingebautes Format, das lokalisierte Tagesnamen zurückgibt:

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

Meine vorherige Lösung (nur für Englisch):

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]
    }
}

Sie müssen Kalender und Komponenten nicht auspacken, sie werden durch das Foundation Framework garantiert.

Verwendung:

print(myDate.dayOfTheWeek())
— Matjan
quelle
5
EEEEE und EEEEEE geben Ihnen Kurzformen der Tage, zB Mi, Do, Fr
— Matjan
1
Oder verwenden Sie die Eigenschaft shortWeekdaySymbols von Calendar, um zu vermeiden, dass ein DateFormatter insgesamt erstellt wird.
— Mikepj
21

Die einfache Antwort (schnell 3):

Calendar.current.component(.weekday, from: Date())
— david72
quelle
10

Es gibt einen einfacheren Weg. Übergeben Sie einfach Ihr String-Datum an die folgende Funktion, es gibt Ihnen den Tagesnamen :)

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);
    }
— Hamid
quelle
2
suchte nach "EEE". Danke
— anoo_radha
10

In meinem Fall war ich nach einer Drei-Buchstaben-Zeichenfolge für jeden Tag. Ich habe die Funktion von @Martin R wie folgt geändert:

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
    }
}
— Tr0yJ
quelle
2
Sie könnten EEE alsdateFormat
— mrvincenzo
9 
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)
}
}

Verwendung let Wochentag = Datum (). Wochentagsname

— Akash Shindhe
quelle
8

Swift 3 Datumsverlängerung

extension Date {
    var weekdayOrdinal: Int {
        return Calendar.current.component(.weekday, from: self)
    }
}
— sehr schön
quelle
Ich habe Ihrer Antwort einen wichtigen Punkt hinzugefügt, nämlich die aktuelle Antwort hier. Natürlich können Sie sich entspannen, wenn Sie nicht mögen! :) Prost
— Fattie
die Frage nach einer ganzen Zahl gestellt
— quemeful
6

Mit dieser Tabelle date_formats können Sie Ihr Datum in verschiedene Formate konvertieren. Mein kürzester Code:

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
— QWERTY-Reloader
quelle
Vielen Dank Dies ist, was ich gesucht habe formatter.dateFormat = "eeee" // "eeee" -> Freitag
— Mohammed Abunada
3

Die praktische Lösung ...

Beachten Sie, dass die Ergebnisse die ganzen Zahlen eins bis sieben sind.

(Nicht null bis sechs.)

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

und dann ...

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

Hier gibt es bereits viele Antworten, aber ich denke, es gibt eine andere, vielleicht bessere Möglichkeit, dies mit den richtigen CalendarAPIs zu tun .

Ich würde vorschlagen, den Wochentag mit der weekdaySymbolsEigenschaft von Calendar( docs ) in einer Erweiterung auf 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]
    }
}

Dies erfordert die Initialisierung einer Dateersten, was ich mit einem benutzerdefinierten tun würde 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
    }
}

Dies kann dann aufgerufen werden mit:

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

Warum ich das bevorzuge:

  1. dayOfWeek Zeitzonen müssen nicht berücksichtigt werden, da der Kalender des Benutzers verwendet wird. Einige der anderen Lösungen hier zeigen den falschen Tag an, da Zeitzonen nicht berücksichtigt werden.
  2. Es ist sehr wahrscheinlich, dass Sie an anderen Stellen Datumsangaben im gleichen Format verwenden müssen. Warum also nicht eine wiederverwendbare Datei erstellen DateFormatterund diese stattdessen verwenden?
  3. weekdaySymbols ist für Sie lokalisiert.
  4. weekDaySymbolskann durch andere Optionen wie shortWeekdaySymbols"Mo", "Di" usw. ersetzt werden.

Bitte beachten Sie: In diesem Beispiel werden DateFormatterauch Zeitzonen oder Gebietsschemas nicht berücksichtigt. Sie müssen sie für die gewünschten Einstellungen festlegen. Wenn die Daten immer genau sind, sollten Sie die Zeitzone festlegen TimeZone(secondsFromGMT: 0).

— Leon
quelle
1
Es ist erstaunlich, dass dies die einzige Antwort ist, die erwähnt weekdaySymbols, danke
— Fattie
3

SWIFT 5 - Wochentag

    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"]
        }
     }

Datumsverlängerung basierend auf Fatties Antwort

— Dili
quelle
1

Ab dem Datum brauchte ich ein paar weitere Zeichenfolgen, einschließlich des Datums der Woche (z. B. "5.") und des Monats des Jahres (z. B. August). Im Folgenden sind alle drei Funktionen aufgeführt, die ich basierend auf der Funktion von @Martin R erstellt und so geändert habe, dass 3 Zeichenfolgen zurückgegeben werden:

//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
    }
}
— Tr0yJ
quelle
1

SWIFT 2.0-Code zur Darstellung der aktuellen Woche ab Montag.

@IBAction func show (Absender: 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)

}
— Himanshu
quelle
1

Dieser Code soll die gesamte aktuelle Woche finden. Es ist in Swift 2.0 geschrieben:

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
}

Die Ausgabe sieht folgendermaßen aus:

14. März (Montag) 15. März (Dienstag) 16. März (Mittwoch) 17. März (Donnerstag) 18. März (Freitag) 19. März (Samstag) 20. März (Sonntag)

— Anurag Mehta
quelle
1

Swift 3: Xcode 8-Hilfsfunktion: 

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
    }
}
— aBikis
quelle
1
Dies ist nicht lokalisiert.
— Alexander - Stellen Sie Monica
0

Damit Swift4 den Wochentag vom String erhält

   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
— Sébastien REMY
quelle
Wie unterscheidet sich dies von der ersten Methode in stackoverflow.com/a/25533357/1187415 ?
— Martin R
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.