Is ClassName.staticVaribale the only way to access static variable within the class? I want something like self, but for class. Like class.staticVariable.
-
1you can use: type(of: self).staticVaribalesoumil– soumil2020-01-11 10:06:33 +00:00Commented Jan 11, 2020 at 10:06
-
@soumil Even better, if you have some unknown object (struct) that meets some protocol, and the protocol has a static variable/function, then your suggestion works perfectly!David Hoerl– David Hoerl2020-02-24 19:05:55 +00:00Commented Feb 24, 2020 at 19:05
Add a comment
|
7 Answers
There are two ways to access a static property/method from a non-static property/method:
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) } }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)
}
}
3 Comments
simd
So if we in the same class, but in instance method, we necessary need to write that class name? It just seems weird for me since compiler can definitely infer the class of instance. I just dont want to type the same class name. Would be great if I just can type like class.staticVaribale, but it is not the case?
ABakerSmith
I've updated my answer, sounds like you were looking to use
dynamicType.
Sea Coast of Tibet
In Swift 3 #2 would be
type(of: self).staticPropertyThis 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
Comments
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
5 Comments
simd
Would be an ideal solution, if it could be more generic. Like some extension for all classes, or even for NSObject subclasses. But I think it's not possible to get dynamic class in extension statics.
jhabbott
This is the best solution. There is an accepted proposal to add this to the language anyway. It would be subtly different in that
Self would mean the dynamic type so if the member accessed was overridden it would use the overridden value. Basically this is the best solution as a stop-gap until this is officially part of the language.
GetSwifty
FWIW, this approach doesn't work for subclassed class functions. e.g. if you have
class func thing(), Self.thing() will always call the parent class and never the sub classes.
Eugene Berdnikov
@Peej Since the type alias is explicitly declared as private, you shouldn't assume it works for subclasses
GetSwifty
@EugeneBerdnikov right, but
printConst() is not. Regardless, Self solves the OP issue anyway :)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
3 Comments
edwardmp
@PEEJWEEJ hence my remark that it will be coming in Swift 3.1. I'm sure implementation will follow before 3.1 is released.
edwardmp
@PEEJWEEJ right, seems I am not up to date in this case. Then we'll have to wait but since it is accepted, it should be released in the near future.
Nhat
Status: Accepted with revisions. not implemented yet?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.
Comments
It looks like in Swift 4.2 the inner class and instance variable can directly access the static variable without the prefix of the class name. However, you still need the class name within a function.
class MyClass {
static let staticProperty = 0
let property = staticProperty //YES
class Inner {
func method() {
print(staticProperty) //YES
}
}
func method() {
print(staticProperty) //NO
print(MyClass.staticProperty) //YES
}
}
Comments
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
}
}
