Obtenez le jour de la semaine en utilisant NSDate

90

J'ai créé une méthode qui est censée prendre une chaîne sous la forme "AAAA-MM-JJ" et cracher un int qui représente la position des dates par rapport à la semaine dans laquelle elle se trouve (peu importe si elle se chevauche entre les mois). 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.WeekdayOrdinalCalendarc'est faux mais j'ai essayé, je pense, les combinaisons les plus logiques. Et ont aussi déconné avec myComponents.weekdayOrdinalpar exemple utilisé mycomponents.dayou .weekday.

Voici mes options d'utilisation:

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 car il n'y a pas d'option DayOfWeekUnit (ou quelque chose de similaire).

swift  nsdate  nscalendar 
— Boidkan
source
1
Voir: Dates et heures de formatage ICU pour le formatage des caractères.
— zaph
— Suhaib
1
@Suhaib Si vous regardez mes balises, il est dit Swift et non Objective-C. De plus, le code est en Swift 2.
— boidkan
essayez le "EEEE" suivant dans votre format de date
— Alexandros

Réponses:

118

Ce que vous recherchez (si je comprends bien la question) est NSCalendarUnit.CalendarUnitWeekday. La propriété correspondante de NSDateComponentsestweekday .

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, vous utilisez également beaucoup de variables où les constantes sont suffisantes. De plus, la fonction doit renvoyer un optionnel qui estnil à 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
    }
}
— Martin R
source
Oui, c'était le format qui me dérangeait. J'avais 2 au lieu de 4 quand j'ai essayé WeekdayCalendarUnit et j'étais très confus! Merci pour le lien, je vais lire dessus.
— boidkan
1
Je sais que cela ne fait pas partie de la question d'origine, mais ce serait un bon endroit pour renvoyer un Int facultatif dans le cas où la date passée n'est pas dans le format correct ou invalide d'une manière ou d'une autre.
— Mike S
1
Cela ne devrait pas être le cas func getDayOfWeek(today:String)->Int?. Si vous forcez le déballage de l'option, il plante toujours, n'est-ce pas?
— HAS
1
@HAS: Vous avez tout à fait raison, merci! - Il ne s'est pas écrasé dans mon cas de test car l'affectation optionnelle if let ...fonctionne également avec des options implicitement non emballées.
— Martin R
1
Merci Marting Pour cela, pour rendre votre réponse plus belle, vous pouvez la modifier pour supprimer le code swift 2 et conserver le code swift 3. Ensuite, ajoutez une note à la fin en disant: "Si vous avez besoin de code pour swift 2, vérifiez la modification précédente" ou quelque chose comme ça
— Suhaib
155

Swift 3 et 4

La récupération du numéro du jour de la semaine est considérablement simplifiée dans Swift 3 car elle DateComponentsn'est plus facultative. Le voici en 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
— brandonscript
source
1
Peut-être que ce serait plus clair si vous mettez aDate.dayOfWeek () sous Usage.
— boidkan
1
Notez que la question était de savoir comment obtenir le jour de la semaine à partir d'une chaîne sous la forme "AAAA-MM-JJ". Bien sûr, cela simplifie si vous avez déjà un NSDate.
— Martin R
4
Cela vaut probablement la peine de mentionner que si vous l'utilisez par exemple. table, cela peut ralentir le défilement, car la création de DateFormatter est assez coûteuse. Si vous allez l'utiliser très souvent, c'est bon, par exemple. créez une instance et fournissez-la pendant le calcul à tous les appels de fonction.
— Vive
Absolument. Dans ce cas, même avoir un gestionnaire de tableau où vous pourriez exécuter la fonction sur un tableau de données serait utile.
— brandonscript
1
plus simple serait juste la réponse de @ david72 ci-dessous: Calendar.current.component (.weekday, from: Date ())
— Adam Smaka
37

Si vous voulez le «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éballer le calendrier et les composants, ils sont garantis par le framework de base.

Usage:

print(myDate.dayOfTheWeek())
— Matjan
source
5
EEEEE et EEEEEE vous donnent des formes abrégées des jours, par exemple mer, jeu, ve
— Matjan
1
Ou utilisez la propriété shortWeekdaySymbols de Calendar pour éviter de créer complètement un DateFormatter.
— mikepj
22

La réponse simple (rapide 3):

Calendar.current.component(.weekday, from: Date())
— David72
source
11

Dans mon cas, je cherchais 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
    }
}
— Tr0yJ
source
2
Vous pouvez utiliser EEE commedateFormat
— mrvincenzo
10

Il existe un moyen plus simple. Passez simplement votre chaîne de date à 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);
    }
— Hamid
source
2
cherchait "EEE". Thanx
— anoo_radha
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)
}
}

utilisation let jour de la semaine = Date (). nom de la semaine

— Akash Shindhe
source
8

Extension de date Swift 3

extension Date {
    var weekdayOrdinal: Int {
        return Calendar.current.component(.weekday, from: self)
    }
}
— émouvant
source
J'ai ajouté un point important à votre réponse, qui est la réponse à jour ici. N'hésitez pas à vous détendre si vous n'aimez pas! :) Cheers
— Fattie
la question posée pour un entier
— quemeful
6

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
— qwerty-reloader
source
Merci beaucoup C'est ce que je cherchais formatter.dateFormat = "eeee" // "eeee" -> Vendredi
— Mohammed Abunada
4

SWIFT 5 - Jour de la semaine

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

Extension de date basée sur la réponse de Fattie

— Dili
source
3

La solution pratique ...

Sachez que les résultats sont les entiers de un à sept.

(Pas de 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] )
— Fattie
source
3

Il y a déjà beaucoup de réponses ici, mais je pense qu'il y a une autre façon, peut-être meilleure, de le faire en utilisant le bon Calendar API .

Je suggère d'obtenir le jour de la semaine en utilisant la weekdaySymbolspropriété de Calendar( docs ) dans une extension à 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'initialiser un Datepremier, ce que je ferais en utilisant un custom 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
    }
}

Cela peut alors être appelé avec:

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

Pourquoi je préfère ceci:

  1. dayOfWeek n'a pas à se soucier des fuseaux horaires car le calendrier de l'utilisateur est utilisé, certaines des autres solutions présentées ici afficheront le jour incorrect car les fuseaux horaires ne sont pas pris en compte.
  2. Il est très probable que vous deviez utiliser des dates dans le même format dans d'autres endroits, alors pourquoi ne pas créer un fichier réutilisable DateFormatteret l'utiliser à la place?
  3. weekdaySymbols est localisé pour vous.
  4. weekDaySymbolspeut être remplacé par d'autres options telles que shortWeekdaySymbols"Mon", "Mar", etc.

Remarque: cet exemple DateFormatterne prend pas non plus en compte les fuseaux horaires ou les paramètres régionaux, vous devrez les définir en fonction de vos besoins. Si les dates sont toujours précises, envisagez de définir le fuseau horaire TimeZone(secondsFromGMT: 0).

— Léon
source
1
C'est étonnant que ce soit la seule réponse qui mentionne weekdaySymbols, merci
— Fattie
1

J'ai fini par avoir besoin de quelques chaînes de plus de la date, y compris la date de la semaine (par exemple "5") et le mois de l'année (par exemple août). Vous trouverez ci-dessous les trois fonctions que j'ai créées sur la base 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
    }
}
— Tr0yJ
source
1

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)

}
— Himanshu
source
1

Ce code permet de retrouver 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
}

La sortie sera comme ceci:

14 mars (lundi) 15 mars (mardi) 16 mars (mercredi) 17 mars (jeudi) 18 mars (vendredi) 19 mars (samedi) 20 mars (dimanche)

— Anurag Mehta
source
1

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
    }
}
— aBikis
source
1
Ce n'est pas localisé.
— Alexander - Réintègre Monica
0

Pour Swift4 pour obtenir 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
— Sébastien REMY
source
En quoi est-ce différent de la première méthode de stackoverflow.com/a/25533357/1187415 ?
— Martin R
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.