J'ai créé une méthode supposée prendre une chaîne sous la forme "AAAA-MM-JJ" et cracher un int qui représente la position de la date par rapport à la semaine dans laquelle elle se trouve (qu'elle se chevauche ou non). Donc, par exemple dimanche = 1 lundi = 2 et ainsi de suite.
Voici mon 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
}
Je sais que NSCalendarUnit.WeekdayOrdinalCalendar
a tort, mais j’ai essayé la plupart des combinaisons logiques. Et vous vous êtes également amusé avec myComponents.weekdayOrdinal
par exemple, vous avez utilisé mycomponents.day
ou .weekday
.
Voici mes options dans quoi utiliser:
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 }
Ce n'est pas clair pour moi puisqu'il n'y a pas d'option DayOfWeekUnit (ou quelque chose de similaire).
Ce que vous recherchez (si je comprends bien la question) est NSCalendarUnit.CalendarUnitWeekday
. La propriété correspondante de NSDateComponents
est weekday
.
Notez également que votre format de date est incorrect (la spécification complète peut être trouvée ici: http://unicode.org/reports/tr35/tr35-6.html ).
La fonction peut être légèrement simplifiée, en utilisant l'inférence de type automatique, mais vous utilisez également beaucoup de variables pour lesquelles les constantes sont suffisantes. En outre, la fonction doit renvoyer une valeur facultative, nil
, pour une chaîne d'entrée non valide.
Code mis à jour pour Swift 3 et versions ultérieures:
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
}
Exemple:
if let weekday = getDayOfWeek("2014-08-27") {
print(weekday)
} else {
print("bad input")
}
Réponse originale pour 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
}
}
La récupération du numéro du jour de la semaine est considérablement simplifiée dans Swift 3, car DateComponents
n'est plus facultatif. La voici comme une extension:
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
Si vous recherchez la version écrite et localisée du jour de la semaine:
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
Si vous voulez l'intégralité du "dimanche", "lundi", "mardi", "mercredi" etc.
EDIT: Il existe en fait un format intégré qui renvoie les noms de jour localisés:
extension NSDate {
func dayOfTheWeek() -> String? {
let dateFormatter = NSDateFormatter()
dateFormatter.dateFormat = "EEEE"
return dateFormatter.stringFromDate(self)
}
}
Ma solution précédente (pour l'anglais uniquement):
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]
}
}
Vous n'avez pas besoin de décompresser le calendrier et les composants, ils sont garantis par la structure de base.
Usage:
print(myDate.dayOfTheWeek())
La réponse simple (Swift 3):
Calendar.current.component(.weekday, from: Date())
Dans mon cas, j'étais après une chaîne de trois lettres pour chaque jour. J'ai modifié la fonction de @Martin R comme suit:
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
}
}
Il y a un moyen plus facile. Passez simplement la date de votre chaîne à la fonction suivante, elle vous donnera le nom du jour :)
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);
}
extension de date Swift
extension Date {
var weekdayOrdinal: Int {
return Calendar.current.component(.weekday, from: self)
}
}
Vous pouvez utiliser cette table date_formats pour convertir votre date en différents formats. Mon code le plus court:
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
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)
}
}
utilisation let weekday = Date (). nom_jour
Il y a déjà beaucoup de réponses ici, mais je pense qu'il existe un autre moyen, peut-être meilleur, de le faire en utilisant les API Calendar
correctes.
Je suggèrerais d'obtenir le jour de la semaine en utilisant la propriété weekdaySymbols
de Calendar
( docs ) dans une extension de 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]
}
}
Cela nécessite d’abord d’initialiser un Date
, ce que je ferais avec un DateFormatter
personnalisé:
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
}
}
Ceci peut alors être appelé avec:
DateFormatter.standardDate.date(from: "2018-09-18")!.dayOfWeek
Pourquoi je préfère ceci:
dayOfWeek
ne doit pas se soucier des fuseaux horaires car le calendrier de l'utilisateur est utilisé. Certaines des autres solutions présentées ici indiqueront le jour incorrect car les fuseaux horaires ne sont pas pris en compte.DateFormatter
réutilisable et l'utiliser à la place?weekdaySymbols
est localisé pour vous.weekDaySymbols
peut être remplacé par d'autres options telles que shortWeekdaySymbols
pour "Mon", "Mardi" etc. Remarque: Cet exemple DateFormatter
ne prend pas non plus en compte les fuseaux horaires ou les paramètres régionaux, vous devez les définir pour ce dont vous avez besoin. Si les dates sont toujours précises, définissez le fuseau horaire TimeZone(secondsFromGMT: 0)
.
La solution pratique ...
Sachez que les résultats sont les entiers de un à sept.
(Pas zéro à six.)
let trivialDayStringsORDINAL = ["", "Sun","MON","TUE","WED","THU","FRI","SAT"]
// note that zero is not used
puis ...
let dow = Calendar.current.component(.weekday, from: someDate)
print( trivialDayStringsORDINAL[dow] )
Ce code sert à trouver toute la semaine en cours. Il est écrit en Swift 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
}
Le résultat sera comme ceci:
14 mars (lundi) 15 mars (mardi) 16 mars (mercredi) 17 mars (jeudi) 18 mars (vendredi) 19 mars (samedi) 20 mars (dimanche)
J'ai fini par avoir besoin de quelques chaînes supplémentaires à partir de la date, y compris la date de la semaine (par exemple, "5ème") et le mois de l'année (par exemple, août). Vous trouverez ci-dessous les trois fonctions que j'ai créées en fonction de la fonction de @Martin R et modifiées pour renvoyer 3 chaînes de caractères:
//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
}
}
Swift 3: fonction d'assistance 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
}
}
Code Swift 2.0 pour présenter la semaine en cours à partir du lundi.
@IBAction func show (expéditeur: 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)
}
Pour que Swift4 obtienne le jour de la semaine à partir de la chaîne
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