อะไรคือข้อแตกต่างระหว่าง static func กับ class func ใน Swift?

ฉันเห็นคำจำกัดความเหล่านี้ในห้องสมุด Swift:

extension Bool : BooleanLiteralConvertible {
    static func convertFromBooleanLiteral(value: Bool) -> Bool
}

protocol BooleanLiteralConvertible {
    typealias BooleanLiteralType
    class func convertFromBooleanLiteral(value: BooleanLiteralType) -> Self
}

ความแตกต่างระหว่างฟังก์ชั่นสมาชิกที่ถูกนิยามว่าเป็นอะไรstatic funcและฟังก์ชั่นอื่น ๆ ที่นิยามไว้เป็นclass funcอย่างไร? มันเป็นเพียงที่staticฟังก์ชั่นคงที่ของ structs และ enums และclassสำหรับชั้นเรียนและโปรโตคอล? มีความแตกต่างอื่น ๆ ที่เราควรรู้หรือไม่? เหตุผลในการมีความแตกต่างนี้ในไวยากรณ์ของตัวเองคืออะไร?

มันเป็นเพียงแค่ว่าคงเป็นฟังก์ชั่นคงที่ของ structs และ enums และชั้นเรียนสำหรับชั้นเรียนและโปรโตคอล?

นั่นคือความแตกต่างที่สำคัญ ความแตกต่างอื่น ๆ คือฟังก์ชันคลาสจะถูกส่งแบบไดนามิกและสามารถแทนที่ได้ด้วยคลาสย่อย

โปรโตคอลใช้คีย์เวิร์ดของคลาส แต่ไม่ได้ยกเว้น structs จากการนำโพรโทคอลไปใช้พวกเขาเพียง แต่ใช้สแตติกแทน Class ถูกเลือกสำหรับโปรโตคอลดังนั้นจึงไม่จำเป็นต้องมีคีย์เวิร์ดที่สามเพื่อแทนสแตติกหรือคลาส

จาก Chris Lattner ในหัวข้อนี้:

เราพิจารณาการรวมไวยากรณ์ (เช่นการใช้ "type" เป็นคำหลัก) แต่นั่นไม่ได้เป็นเรื่องง่าย คำหลัก "class" และ "static" นั้นดีสำหรับความคุ้นเคยและค่อนข้างจะเป็นคำอธิบาย (เมื่อคุณเข้าใจวิธี + วิธีการทำงาน) และเปิดประตูสำหรับการเพิ่มวิธีการคงที่ให้กับคลาสอย่างแท้จริง ความแปลกประหลาดหลักของรุ่นนี้คือโปรโตคอลจะต้องเลือกคำหลัก (และเราเลือก "คลาส") แต่ในความสมดุลมันคือการแลกเปลี่ยนที่ถูกต้อง

และนี่คือตัวอย่างข้อมูลที่แสดงพฤติกรรมการแทนที่ของฟังก์ชันคลาส:

class MyClass {
    class func myFunc() {
        println("myClass")
    }
}

class MyOtherClass: MyClass {
    override class func myFunc() {
        println("myOtherClass")
    }
}

var x: MyClass = MyOtherClass()
x.dynamicType.myFunc() //myOtherClass
x = MyClass()
x.dynamicType.myFunc() //myClass

เพื่อความชัดเจนฉันทำตัวอย่างที่นี่

class ClassA {
  class func func1() -> String {
    return "func1"
  }

  static func func2() -> String {
    return "func2"
  }

  /* same as above
  final class func func2() -> String {
    return "func2"
  }
  */
}

static func เป็นเช่นเดียวกับ final class func

เพราะมันเป็นfinalเราไม่สามารถแทนที่มันในคลาสย่อยดังต่อไปนี้:

class ClassB : ClassA {
  override class func func1() -> String {
    return "func1 in ClassB"
  }

  // ERROR: Class method overrides a 'final` class method
  override static func func2() -> String {
    return "func2 in ClassB"
  }
}

ฉันทำการทดลองในสนามเด็กเล่นและได้ข้อสรุป

TL; DR

อย่างที่คุณเห็นในกรณีของclassการใช้class funcหรือstatic funcเป็นเพียงคำถามเกี่ยวกับนิสัย

ตัวอย่างสนามเด็กเล่นพร้อมคำอธิบาย:

class Dog {
    final func identity() -> String {
        return "Once a woofer, forever a woofer!"
    }

    class func talk() -> String {
        return "Woof woof!"
    }

    static func eat() -> String {
        return "Miam miam"
    }

    func sleep() -> String {
        return "Zzz"
    }
}

class Bulldog: Dog {
    // Can not override a final function
//    override final func identity() -> String {
//        return "I'm once a dog but now I'm a cat"
//    }

    // Can not override a "class func", but redeclare is ok
    func talk() -> String {
        return "I'm a bulldog, and I don't woof."
    }

    // Same as "class func"
    func eat() -> String {
        return "I'm a bulldog, and I don't eat."
    }

    // Normal function can be overridden
    override func sleep() -> String {
        return "I'm a bulldog, and I don't sleep."
    }
}

let dog = Dog()
let bullDog = Bulldog()

// FINAL FUNC
//print(Dog.identity()) // compile error
print(dog.identity()) // print "Once a woofer, forever a woofer!"
//print(Bulldog.identity()) // compile error
print(bullDog.identity()) // print "Once a woofer, forever a woofer!"

// => "final func" is just a "normal" one but prevented to be overridden nor redeclared by subclasses.


// CLASS FUNC
print(Dog.talk()) // print "Woof woof!", called directly from class
//print(dog.talk()) // compile error cause "class func" is meant to be called directly from class, not an instance.
print(Bulldog.talk()) // print "Woof woof!" cause it's called from Bulldog class, not bullDog instance.
print(bullDog.talk()) // print "I'm a bulldog, and I don't woof." cause talk() is redeclared and it's called from bullDig instance

// => "class func" is like a "static" one, must be called directly from class or subclassed, can be redeclared but NOT meant to be overridden.

// STATIC FUNC
print(Dog.eat()) // print "Miam miam"
//print(dog.eat()) // compile error cause "static func" is type method
print(Bulldog.eat()) // print "Miam miam"
print(bullDog.eat()) // print "I'm a bulldog, and I don't eat."

// NORMAL FUNC
//print(Dog.sleep()) // compile error
print(dog.sleep()) // print "Zzz"
//print(Bulldog.sleep()) // compile error
print(bullDog.sleep()) // print "I'm a bulldog, and I don't sleep."

หากต้องการประกาศคุณสมบัติตัวแปรชนิดให้ทำเครื่องหมายการประกาศด้วยstaticตัวแก้ไขการประกาศ คลาสอาจทำเครื่องหมายคุณสมบัติที่คำนวณได้ของชนิดด้วยโมดิclassฟายเออร์การประกาศแทนเพื่ออนุญาตให้คลาสย่อยแทนที่การใช้งานของซูเปอร์คลาส คุณสมบัติของประเภทจะกล่าวถึงในคุณสมบัติของประเภท

หมายเหตุ
ในการประกาศคลาสคำสำคัญstaticมีผลเช่นเดียวกับการทำเครื่องหมายการประกาศที่มีทั้งตัวดัดแปลงclassและfinalการประกาศ

ที่มา: ภาษาการเขียนโปรแกรม Swift - คุณสมบัติตัวแปรชนิด

อ้างอิงจาก Swift 2.2 Book ที่ตีพิมพ์โดย apple:

“ คุณระบุวิธีการพิมพ์โดยการเขียนstaticคำสำคัญหน้าคำหลัก func ของวิธีการ คลาสอาจใช้classคำสำคัญเพื่ออนุญาตให้คลาสย่อยแทนที่การใช้วิธีดังกล่าวของซูเปอร์คลาส ”

จาก Swift2.0, Apple พูดว่า:

"ข้อกำหนดคุณสมบัติของส่วนนำหน้าเสมอด้วยคีย์เวิร์ดแบบสแตติกเมื่อคุณกำหนดไว้ในโปรโตคอลกฎนี้เกี่ยวข้องแม้ว่าข้อกำหนดคุณสมบัติของประเภทสามารถนำหน้าด้วยคลาสหรือคีย์เวิร์ดแบบสแตติกเมื่อใช้งานโดยคลาส:"

ตัวอย่างนี้จะล้างทุกแง่มุม!

import UIKit

class Parent {
    final func finalFunc() -> String { // Final Function, cannot be redeclared.
        return "Parent Final Function."
    }

    static func staticFunc() -> String { // Static Function, can be redeclared.
        return "Parent Static Function."
    }

    func staticFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Static Function, redeclared with same name but as non-static(normal) function."
    }

    class func classFunc() -> String { // Class Function, can be redeclared.
        return "Parent Class Function."
    }

    func classFunc() -> String { // Above function redeclared as Normal function.
        return "Parent Class Function, redeclared with same name but as non-class(normal) function."
    }

    func normalFunc() -> String { // Normal function, obviously cannot be redeclared.
        return "Parent Normal Function."
    }
}

class Child:Parent {

    // Final functions cannot be overridden.

    override func staticFunc() -> String { // This override form is of the redeclared version i.e: "func staticFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Static Function redeclared and overridden, can simply be called Child Normal Function."
    }

    override class func classFunc() -> String { // Class function, can be overidden.
        return "Child Class Function."
    }

    override func classFunc() -> String { // This override form is of the redeclared version i.e: "func classFunc()" so just like any other function of normal type, it can be overridden.
        return "Child Class Function, redeclared and overridden, can simply be called Child Normal Function."
    }

    override func normalFunc() -> String { // Normal function, can be overridden.
        return "Child Normal Function."
    }
}

let parent = Parent()
let child = Child()

// Final
print("1. " + parent.finalFunc())   // 1. Can be called by object.
print("2. " + child.finalFunc())    // 2. Can be called by object, parent(final) function will be called.
// Parent.finalFunc()               // Cannot be called by class name directly.
// Child.finalFunc()                // Cannot be called by class name directly.

// Static
print("3. " + parent.staticFunc())  // 3. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("4. " + child.staticFunc())   // 4. Cannot be called by object, this is override form redeclared version (normal function).
print("5. " + Parent.staticFunc())  // 5. Can be called by class name directly.
print("6. " + Child.staticFunc())   // 6. Can be called by class name direcly, parent(static) function will be called.

// Class
print("7. " + parent.classFunc())   // 7. Cannot be called by object, this is redeclared version (i.e: a normal function).
print("8. " + child.classFunc())    // 8. Cannot be called by object, this is override form redeclared version (normal function).
print("9. " + Parent.classFunc())   // 9. Can be called by class name directly.
print("10. " + Child.classFunc())   // 10. Can be called by class name direcly, child(class) function will be called.

// Normal
print("11. " + parent.normalFunc())  // 11. Can be called by object.
print("12. " + child.normalFunc())   // 12. Can be called by object, child(normal) function will be called.
// Parent.normalFunc()               // Cannot be called by class name directly.
// Child.normalFunc()                // Cannot be called by class name directly.

/*
 Notes:
 ___________________________________________________________________________
 |Types------Redeclare------Override------Call by object------Call by Class|
 |Final----------0--------------0---------------1------------------0-------|
 |Static---------1--------------0---------------0------------------1-------|
 |Class----------1--------------1---------------0------------------1-------|
 |Normal---------0--------------1---------------1------------------0-------|
 ---------------------------------------------------------------------------

 Final vs Normal function: Both are same but normal methods can be overridden.
 Static vs Class function: Both are same but class methods can be overridden.
 */

เอาท์พุท:

สิ่งนี้เรียกว่าเมธอด type และถูกเรียกด้วยจุดไวยากรณ์เช่นเมธอดอินสแตนซ์ อย่างไรก็ตามคุณเรียกใช้เมธอดชนิดกับชนิดไม่ใช่ในอินสแตนซ์ของชนิดนั้น นี่คือวิธีที่คุณเรียกใช้เมธอด type บนคลาสที่ชื่อว่า SomeClass: