Access static variables within class in Swift

Question

Is ClassName.staticVaribale the only way to access static variable within the class? I want something like self, but for class. Like class.st

Answer 1

There is a way in Swift to make Marcel's answer satisfy even most picky style-guide gods

class MyClass {

    private typealias `Self` = MyClass

    static let MyConst = 5

    func printConst() {
        print(Self.MyConst)
    }
}

That makes Self available like in protocols when you want access associated type declaration. I am not sure about Swift 1 because never tried it but in Swift 2 it works perfectly

Answer 2

In a future Swift 3 version (yet to be released) you can use Self (yes, that's with a capital) to reference to the containing class. A proposal for this was accepted, but the feature is not implemented yet.

For example:

struct CustomStruct {          
 static func staticMethod() { ... } 

 func instanceMethod() {          
   Self.staticMethod() // in the body of the type          
 }          
}

Source: https://github.com/apple/swift-evolution/blob/master/proposals/0068-universal-self.md

Answer 3

I don't like the typealias way in this case. My workaround is:

class MyClass {

   static let myStaticConst: Int = 1
   var myStaticConst:Int {
      return type(of: self).myStaticConst
   }

   func method() {
      let i:Int = myStaticConst
   }
}

Answer 4

There are two ways to access a static property/method from a non-static property/method:

1. As stated in your question, you can prefix the property/method name with that of the type:

   class MyClass {
       static let staticProperty = 0
   
       func method() {
           print(MyClass.staticProperty)
       }
   }
   

2. Swift 2: You can use dynamicType:

   class MyClass {
       static let staticProperty = 0
   
       func method() {
           print(self.dynamicType.staticProperty)
       }
   }
   

   Swift 3: You can use type(of:) (thanks @Sea Coast of Tibet):

   class MyClass {
       static let staticProperty = 0
   
       func method() {
           print(type(of: self).staticProperty)
       }
   }
   

---

If you're inside a static property/method you do not need to prefix the static property/method with anything:

class MyClass {
    static let staticProperty = 0

    static func staticMethod() {
        print(staticProperty)
    }
}

Answer 5

This is solved elegantly in Swift 5.1 you can access it via

Self.yourConstant

Reference: https://github.com/apple/swift-evolution/blob/master/proposals/0068-universal-self.md

Answer 6

You could work around this by defining a self referencing typealias.

class MyClassWithALongName {
  typealias CLASS = MyClassWithALongName

  static let staticFoo = "foo"

  func someInstanceMethod() -> String {
    return CLASS.staticFoo
  }
}

Though the style-guide gods may not approve.