मैं स्विफ्ट में एक चर के प्रकार या वर्ग को कैसे प्रिंट कर सकता हूं?

335

क्या स्विफ्ट के रनटाइम प्रकार को प्रिंट करने का एक तरीका है? उदाहरण के लिए:

var now = NSDate()
var soon = now.dateByAddingTimeInterval(5.0)

println("\(now.dynamicType)") 
// Prints "(Metatype)"

println("\(now.dynamicType.description()")
// Prints "__NSDate" since objective-c Class objects have a "description" selector

println("\(soon.dynamicType.description()")
// Compile-time error since ImplicitlyUnwrappedOptional<NSDate> has no "description" method

ऊपर दिए गए उदाहरण में, मैं यह दिखाने का तरीका खोज रहा हूं कि चर "जल्द" प्रकार का है ImplicitlyUnwrappedOptional<NSDate>, या कम से कम NSDate!।

swift  types 
— मैट ब्रिज
स्रोत
43
@JasonMArcher मुझे बताएं कि यह डुप्लिकेट कैसे है यदि आपके द्वारा जुड़ा प्रश्न इस एक के 4 दिन बाद पूछा गया था?
— आकाशवाणी
स्विफ्ट ऑब्जेक्ट के प्रकार का परीक्षण करने या स्विफ्ट ऑब्जेक्ट के प्रकार को पढ़ने के बारे में कई प्रश्न हैं। हम सिर्फ इस विषय के लिए "मास्टर" प्रश्नों के रूप में उपयोग करने के लिए सबसे अच्छे प्रश्न ढूंढ रहे हैं। सुझाए गए डुप्लिकेट में बहुत अधिक गहन उत्तर है। यह कहना नहीं है कि आपने कुछ गलत किया है, बस हम अव्यवस्था को कम करने की कोशिश कर रहे हैं।
— जेसनम्रेचर
4
सुझाए गए डुप्लिकेट उसी प्रश्न का उत्तर नहीं दे रहे हैं; प्रकार। स्वयं को डीबगिंग के उद्देश्यों के लिए कंसोल पर मुद्रित नहीं किया जा सकता है, इसका उपयोग अन्य कार्यों को पास करने के लिए किया जाता है जो प्रकार को ऑब्जेक्ट के रूप में लेते हैं।
— मैट ब्रिजेस
2
OT: बहुत अजीब है कि स्विफ्ट बॉक्स से बाहर की पेशकश नहीं करता है और एक को इस तरह के निम्न स्तर के सी पुस्तकालयों के साथ चारों ओर फेलना पड़ता है। एक बग रिपोर्ट के लायक?
— क्वर्टी_सो
दोस्तों, मैंने अपना जवाब नीचे दिया है। कृपया देखें और मुझे बताएं कि क्या उम्मीद है।
— DILIP KOSURI

जवाबों:

377

अपडेट सितंबर 2016

स्विफ्ट 3.0: उपयोग करें type(of:), उदाहरण के लिए type(of: someThing)(चूंकि dynamicTypeकीवर्ड हटा दिया गया है)

अद्यतन अक्टूबर 2015 :

मैंने नई स्विफ्ट 2.0 सिंटैक्स के नीचे दिए गए उदाहरणों को अपडेट किया (उदाहरण के printlnसाथ बदल दिया गया था print, toString()अब है String())।

Xcode 6.3 रिलीज नोट्स से :

@nschum टिप्पणी में बताता है कि Xcode 6.3 रिलीज़ नोट दूसरा रास्ता दिखाते हैं:

टाइप मान अब प्रिंटेलन या स्ट्रिंग इंटरपोलेशन के साथ उपयोग किए जाने पर पूर्ण विखंडित प्रकार के नाम के रूप में प्रिंट होते हैं।

import Foundation

class PureSwiftClass { }

var myvar0 = NSString() // Objective-C class
var myvar1 = PureSwiftClass()
var myvar2 = 42
var myvar3 = "Hans"

print( "String(myvar0.dynamicType) -> \(myvar0.dynamicType)")
print( "String(myvar1.dynamicType) -> \(myvar1.dynamicType)")
print( "String(myvar2.dynamicType) -> \(myvar2.dynamicType)")
print( "String(myvar3.dynamicType) -> \(myvar3.dynamicType)")

print( "String(Int.self)           -> \(Int.self)")
print( "String((Int?).self         -> \((Int?).self)")
print( "String(NSString.self)      -> \(NSString.self)")
print( "String(Array<String>.self) -> \(Array<String>.self)")

कौन से आउटपुट:

String(myvar0.dynamicType) -> __NSCFConstantString
String(myvar1.dynamicType) -> PureSwiftClass
String(myvar2.dynamicType) -> Int
String(myvar3.dynamicType) -> String
String(Int.self)           -> Int
String((Int?).self         -> Optional<Int>
String(NSString.self)      -> NSString
String(Array<String>.self) -> Array<String>

Xcode 6.3 के लिए अपडेट करें:

आप इसका उपयोग कर सकते हैं _stdlib_getDemangledTypeName():

print( "TypeName0 = \(_stdlib_getDemangledTypeName(myvar0))")
print( "TypeName1 = \(_stdlib_getDemangledTypeName(myvar1))")
print( "TypeName2 = \(_stdlib_getDemangledTypeName(myvar2))")
print( "TypeName3 = \(_stdlib_getDemangledTypeName(myvar3))")

और इसे आउटपुट के रूप में प्राप्त करें:

TypeName0 = NSString
TypeName1 = __lldb_expr_26.PureSwiftClass
TypeName2 = Swift.Int
TypeName3 = Swift.String

मूल उत्तर:

Xcode 6.3 से पहले _stdlib_getTypeNameएक चर का mangled प्रकार नाम मिला। इवान स्विक की ब्लॉग प्रविष्टि इन तारों को समझने में मदद करती है:

उदाहरण _TtSiके लिए स्विफ्ट का आंतरिक Intप्रकार है।

माइक ऐश की एक ही विषय को कवर करने वाली एक महान ब्लॉग प्रविष्टि है ।

— क्लास
स्रोत
2
आपको कैसे मिली _stdlib_getTypeName()? एकीकृत REPL अब मौजूद swift-ide-testनहीं है, और या तो मौजूद नहीं है, और स्विफ्ट मॉड्यूल के एक्सकोड की छपाई _-प्रत्यक्ष मान।
— लिली बॉलार्ड
10
ऐसा लगता है कि मैं प्रतीकों को उत्तर में lldbआसानी से पर्याप्त खोज सकता हूं । वहाँ भी है _stdlib_getDemangledTypeName(), और _stdlib_demangleName()।
— लिली बॉलर
1
ओह नीट, मुझे नहीं पता imageथा कि यह एक शॉर्टकट था target modules। मैंने प्रयोग करना समाप्त कर दिया target modules lookup -r -n _stdlib_, जो निश्चित रूप से बेहतर हैimage lookup -r -n _stdlib_ libswiftCore.dylib
— लिली बॉलर
1
FYI करें - ऐसा लगता है कि स्ट्रिंग (...) को स्ट्रिंग (...) से बदल दिया गया है।
— निक
6
स्विफ्ट 3.0: dynamicTypeकीवर्ड को स्विफ्ट से हटा दिया गया है। इसके स्थान पर भाषा में एक नया आदिम कार्य type(of:)जोड़ा गया है: github.com/apple/swift/blob/master/CHANGELOG.md
— Szu
46

संपादित करें: स्विफ्ट 1.2 (Xcode 6.3) में एक नया toStringफ़ंक्शन पेश किया गया है ।

अब आप किसी भी प्रकार के उपयोग के ध्वस्त प्रकार को प्रिंट कर सकते हैं .self और किसी भी उदाहरण का.dynamicType :

struct Box<T> {}

toString("foo".dynamicType)            // Swift.String
toString([1, 23, 456].dynamicType)     // Swift.Array<Swift.Int>
toString((7 as NSNumber).dynamicType)  // __NSCFNumber

toString((Bool?).self)                 // Swift.Optional<Swift.Bool>
toString(Box<SinkOf<Character>>.self)  // __lldb_expr_1.Box<Swift.SinkOf<Swift.Character>>
toString(NSStream.self)                // NSStream

कॉल करने का प्रयास करें YourClass.selfऔर yourObject.dynamicType।

संदर्भ: https://devforums.apple.com/thread/227425 ।

— akashivskyy
स्रोत
2
मैंने उस धागे का जवाब दिया, लेकिन मैं अपनी टिप्पणी यहां जोड़ूंगा। वे मान "मेटाटाइप" प्रकार के हैं, लेकिन यह पता लगाने का एक आसान तरीका नहीं है कि मेटाटाइप ऑब्जेक्ट किस प्रकार का प्रतिनिधित्व करता है, जो कि मैं देख रहा हूं।
— मैट पुल 12
वे टाइप मेटाटाइप के हैं, और वे कक्षाएं हैं। वे एक वर्ग का प्रतिनिधित्व करते हैं। यकीन नहीं होता कि आपकी समस्या क्या है। someInstance.dynamicType.printClassName()वर्ग का नाम प्रिंट करेगा।
— एनालॉग फाइल
18
PrintClassName () विधि डॉक्स में एक नमूने में बनाई गई एक उदाहरण विधि है, यह एक एपीआई कॉल नहीं है जिसे आप एक्सेस कर सकते हैं।
— डेव वुड
4
FYI करें - ऐसा लगता है कि स्ट्रिंग (...) को स्ट्रिंग के साथ बदल दिया गया है ... (...)
— Nick
33

स्विफ्ट 3.0

let string = "Hello"
let stringArray = ["one", "two"]
let dictionary = ["key": 2]

print(type(of: string)) // "String"

// Get type name as a string
String(describing: type(of: string)) // "String"
String(describing: type(of: stringArray)) // "Array<String>"
String(describing: type(of: dictionary)) // "Dictionary<String, Int>"

// Get full type as a string
String(reflecting: type(of: string)) // "Swift.String"
String(reflecting: type(of: stringArray)) // "Swift.Array<Swift.String>"
String(reflecting: type(of: dictionary)) // "Swift.Dictionary<Swift.String, Swift.Int>"
— Evgenii
स्रोत
1
स्विफ्ट 2 कार्यान्वयन विशेष रूप से एनम मामलों के साथ अच्छा है। क्या किसी को पता है कि क्या यह व्यवहार Apple द्वारा प्रलेखित / गारंटीकृत है? मानक पुस्तकालय में केवल एक टिप्पणी शामिल है कि यह डिबगिंग के लिए उपयुक्त है ...
— मिल्स
30

यह वही है जो आप खोज रहे हैं?

println("\(object_getClassName(now))");

यह "__NSDate" प्रिंट करता है

अद्यतन : कृपया ध्यान दें कि यह अब Beta05 के रूप में काम नहीं करता है

— हाइकु ओझु
स्रोत
2
स्विफ्ट क्लासेस के लिए काम नहीं करता है। "UnsafePointer (0x7FB18D06DE0)"
— लौटाता है
4
ObjC कक्षाओं के लिए काम नहीं करता है (या तो कम से कम Beta5 में), एक NSManagedObject के लिए, मुझे बस "Buildin.RawPointer = पता" मिलता है
— Kendall Helmstetter Gelner
23

मेरा वर्तमान Xcode संस्करण 6.0 (6A280e) है।

import Foundation

class Person { var name: String; init(name: String) { self.name = name }}
class Patient: Person {}
class Doctor: Person {}

var variables:[Any] = [
    5,
    7.5,
    true,
    "maple",
    Person(name:"Sarah"),
    Patient(name:"Pat"),
    Doctor(name:"Sandy")
]

for variable in variables {
    let typeLongName = _stdlib_getDemangledTypeName(variable)
    let tokens = split(typeLongName, { $0 == "." })
    if let typeName = tokens.last {
        println("Variable \(variable) is of Type \(typeName).")
    }
}

आउटपुट:

Variable 5 is of Type Int.
Variable 7.5 is of Type Double.
Variable true is of Type Bool.
Variable maple is of Type String.
Variable Swift001.Person is of Type Person.
Variable Swift001.Patient is of Type Patient.
Variable Swift001.Doctor is of Type Doctor.
— मैट हेगन
स्रोत
1
अच्छा है, लेकिन प्रश्न में वैकल्पिक भी शामिल है, वैकल्पिक का आउटपुट इसमें सेट है Optional(...), इसलिए आपका कोड केवल Optionalप्रकार के रूप में वापस आ जाएगा । यह भी var optionalTestVar: Person? = Person(name:"Sarah")वैकल्पिक (व्यक्ति) और व्यक्ति के साथ संस्करण के रूप में दिखाना चाहिए ! इंप्लसली के रूप में UwwrappedOptional (व्यक्ति)
— Binarian
18

स्विफ्ट 1.2 के साथ Xcode 6.3 के रूप में, आप बस प्रकार के मूल्यों को पूर्ण रूप से ध्वस्त कर सकते हैं String।

toString(Int)                   // "Swift.Int"
toString(Int.Type)              // "Swift.Int.Type"
toString((10).dynamicType)      // "Swift.Int"
println(Bool.self)              // "Swift.Bool"
println([UTF8].self)            // "Swift.Array<Swift.UTF8>"
println((Int, String).self)     // "(Swift.Int, Swift.String)"
println((String?()).dynamicType)// "Swift.Optional<Swift.String>"
println(NSDate)                 // "NSDate"
println(NSDate.Type)            // "NSDate.Type"
println(WKWebView)              // "WKWebView"
toString(MyClass)               // "[Module Name].MyClass"
toString(MyClass().dynamicType) // "[Module Name].MyClass"
— kiding
स्रोत
क्या 1.2 में दूसरी दिशा संभव है? वर्ग के नाम के आधार पर एक उदाहरण इनिशियलाइज़ करने के लिए?
— user965972
@ user965972 जहाँ तक मुझे पता है मुझे नहीं लगता कि कोई भी है।
— kiding
17

आप अभी भी, के माध्यम से वर्ग का उपयोग कर सकते हैं className (जिसके रिटर्न देता हैString )।

उदाहरण के लिए classForArchiver, वास्तव में कक्षा को प्राप्त करने के कई तरीके हैं ,classForCoder , classForKeyedArchiver(सभी वापसीAnyClass! )।

आप एक आदिम का प्रकार नहीं प्राप्त कर सकते हैं (एक आदिम नहीं है वर्ग है)।

उदाहरण:

var ivar = [:]
ivar.className // __NSDictionaryI

var i = 1
i.className // error: 'Int' does not have a member named 'className'

यदि आप एक आदिम का प्रकार प्राप्त करना चाहते हैं, तो आपको उपयोग करना होगा bridgeToObjectiveC()। उदाहरण:

var i = 1
i.bridgeToObjectiveC().className // __NSCFNumber
— Leandros
स्रोत
मुझे यकीन है कि यह एक आदिम है। दुर्भाग्य से आप एक आदिम का प्रकार नहीं प्राप्त कर सकते हैं।
— लिएन्ड्रोस
वे उदाहरण खेल के मैदान में काम नहीं करते। मुझे आदिम और गैर-आदिम के लिए समान रूप से त्रुटि मिलती है।
— मैट ब्रिजेस
करने की कोशिश करो import Cocoa।
— लिएंड्रो
9
OSN के लिए विकसित करते समय क्लासनेम केवल NSObjects के लिए उपलब्ध प्रतीत होता है; यह NSObjects या "सामान्य" ऑब्जेक्ट्स के लिए iOS SDK में उपलब्ध नहीं है
— मैट ब्रिजेस
3
classNameकोको के AppleScript समर्थन का हिस्सा है और निश्चित रूप से सामान्य आत्मनिरीक्षण के लिए इस्तेमाल नहीं किया जाना चाहिए। जाहिर है कि यह iOS पर उपलब्ध नहीं है।
— निकोलाई रुहे
16

आप वस्तु के बारे में जानकारी प्राप्त करने के लिए प्रतिबिंबित का उपयोग कर सकते हैं।
उदाहरण के लिए ऑब्जेक्ट क्लास का नाम:

var classname = प्रतिबिंबित (अब) .summary
— स्टेन
स्रोत
बीटा 6 में, इसने मुझे थोड़ा नामांकित रूप में ऐप का नाम + वर्ग नाम दिया, लेकिन यह एक शुरुआत है। +1 के लिए reflect(x).summary- धन्यवाद!
— ओली
काम नहीं किया, स्विफ्ट 1.2 Xcode 6.4 में एक रिक्त लाइन को प्रिंट करता है और iO 8.4
— जुआन बोरो
13

मेरे साथ किस्मत थी:

let className = NSStringFromClass(obj.dynamicType)
— mxcl
स्रोत
@ दोस्त दोस्त काम नहीं किया, लेकिन classForCoder ने काम किया।
— सर्वेश्वरन
10

Xcode 8 में, स्विफ्ट 3.0

कदम:

1. प्रकार प्राप्त करें:

विकल्प 1:

let type : Type = MyClass.self  //Determines Type from Class

विकल्प 2:

let type : Type = type(of:self) //Determines Type from self

2. स्ट्रिंग में कनवर्ट प्रकार:

let string : String = "\(type)" //String
— user1046037
स्रोत
7

स्विफ्ट 5

स्विफ्ट 3 की नवीनतम रिलीज के साथ हम शुरुआती नाम के माध्यम से प्रकार के नामों का सुंदर विवरण प्राप्त कर सकते हैं String। जैसे, उदाहरण के लिए print(String(describing: type(of: object)))। जहाँ object एक उदाहरण चर हो सकता है जैसे सरणी, एक शब्दकोश, एक Int, NSDateएक कस्टम वर्ग का एक उदाहरण, आदि।

यहाँ मेरा पूरा जवाब है: स्विफ्ट में स्ट्रिंग के रूप में ऑब्जेक्ट का वर्ग नाम प्राप्त करें

यह प्रश्न किसी वस्तु के वर्ग नाम को स्ट्रिंग के रूप में प्राप्त करने का एक तरीका है, लेकिन, मैंने एक चर के वर्ग नाम को प्राप्त करने का दूसरा तरीका भी प्रस्तावित किया है जो उप-वर्ग नहीं है NSObject। यह रहा:

class Utility{
    class func classNameAsString(obj: Any) -> String {
        //prints more readable results for dictionaries, arrays, Int, etc
        return String(describing: type(of: obj))
    }
}

मैंने एक स्टैटिक फंक्शन बनाया जो पैरामीटर को एक प्रकार की वस्तु के रूप में लेता है Anyऔर इसके वर्ग नाम को वापस करता हैString :) के ।

मैंने इस फ़ंक्शन को कुछ चरों के साथ परखा: 

    let diccionary: [String: CGFloat] = [:]
    let array: [Int] = []
    let numInt = 9
    let numFloat: CGFloat = 3.0
    let numDouble: Double = 1.0
    let classOne = ClassOne()
    let classTwo: ClassTwo? = ClassTwo()
    let now = NSDate()
    let lbl = UILabel()

और आउटपुट था:

  • डिक्शनरी शब्द डिक्शनरी का है
  • एरे टाइप अर्रे का है
  • numInt इंट का प्रकार है
  • numFloat CGFloat प्रकार का है
  • numDouble टाइप डबल है
  • classOne टाइप का होता है: ClassOne
  • ClassTwo टाइप का होता है: ClassTwo
  • अब प्रकार है: दिनांक
  • lbl टाइप का है: UILabel
— mauricioconde
स्रोत
5

कोको (कोकोआ नहीं) का उपयोग करते समय, आप उन classNameवस्तुओं के लिए संपत्ति का उपयोग कर सकते हैं जो NSObject के उपवर्ग हैं।

println(now.className)

यह संपत्ति सामान्य स्विफ्ट वस्तुओं के लिए उपलब्ध नहीं है, जो NSObject के उपवर्ग नहीं हैं (और वास्तव में, स्विफ्ट में कोई रूट आईडी या ऑब्जेक्ट प्रकार नहीं है)।

class Person {
    var name: String?
}

var p = Person()
println(person.className) // <- Compiler error

कोकोआटच में, इस समय किसी दिए गए चर के प्रकार का एक स्ट्रिंग विवरण प्राप्त करने का एक तरीका नहीं है। इसी तरह की कार्यक्षमता भी कोको या कोकोआटम में आदिम प्रकारों के लिए मौजूद नहीं है।

स्विफ्ट आरईपीएल अपने प्रकार सहित मूल्यों का एक सारांश प्रिंट करने में सक्षम है, इसलिए यह संभव है कि भविष्य में एपीआई के माध्यम से आत्मनिरीक्षण का यह तरीका संभव होगा।

संपादित करें : dump(object)चाल करने के लिए लगता है।

— मैट ब्रिज
स्रोत
यहां तक ​​कि Xcode 10 और Swift 4.2 के रूप में, dump(object)वास्तव में शक्तिशाली है। धन्यवाद।
— एलेक्स ज़ावाटोन
5

शीर्ष उत्तर में इस का उपयोग करने के नए तरीके का एक कार्यशील उदाहरण नहीं है type(of:। तो मेरे जैसे बदमाशों की मदद करने के लिए, यहाँ एक काम करने का उदाहरण दिया गया है, जो ज्यादातर Apple के डॉक्स से लिया गया है - https://developer.apple.com/documentation/swift/2885064-type

doubleNum = 30.1

func printInfo(_ value: Any) {
    let varType = type(of: value)
    print("'\(value)' of type '\(varType)'")
}

printInfo(doubleNum)
//'30.1' of type 'Double'
— यहोशू नृत्य
स्रोत
4

मैंने यहाँ कुछ अन्य जवाबों की कोशिश की है, लेकिन लगता है कि अंडरलिंग ऑब्जेक्ट क्या है।

हालाँकि मुझे एक ऐसा तरीका मिला जो आप ऑब्जेक्ट-सी क्लास का नाम किसी ऑब्जेक्ट के लिए निम्न करके प्राप्त कर सकते हैं:

now?.superclass as AnyObject! //replace now with the object you are trying to get the class name for

यहां बताया गया है कि आप इसका उपयोग कैसे करेंगे:

let now = NSDate()
println("what is this = \(now?.superclass as AnyObject!)")

इस स्थिति में यह NSDate को कंसोल में प्रिंट करेगा।

— जेम्स जोन्स
स्रोत
4

मुझे यह समाधान मिला जो उम्मीद है कि किसी और के लिए काम कर सकता है। मैंने मूल्य तक पहुंचने के लिए एक वर्ग विधि बनाई। कृपया ध्यान रखें कि यह केवल NSObject उपवर्ग के लिए काम करेगा। लेकिन कम से कम एक साफ और सुव्यवस्थित समाधान है।

class var className: String!{
    let classString : String = NSStringFromClass(self.classForCoder())
    return classString.componentsSeparatedByString(".").last;
}
— DennyLou
स्रोत
4

स्विफ्ट 1.2 के साथ नवीनतम XCode 6.3 में, यह एकमात्र तरीका है जो मैंने पाया:

if view.classForCoder.description() == "UISegment" {
    ...
}
— जोएल कोपेलियॉफ़
स्रोत
नोट: विवरण () प्रारूप में वर्ग का नाम देता है <swift module name>.<actual class name>, इसलिए आप स्ट्रिंग को एक .और अंतिम टोकन के साथ विभाजित करना चाहते हैं ।
— मैथ्यू क्विरोस
4

यहाँ कई उत्तर नवीनतम स्विफ्ट (लेखन के समय Xcode 7.1.1) के साथ काम नहीं करते हैं।

जानकारी प्राप्त करने का वर्तमान तरीका ए Mirrorऔर पूछताछ करना है। वर्गनाम के लिए यह उतना ही सरल है:

let mirror = Mirror(reflecting: instanceToInspect)
let classname:String = mirror.description

वस्तु के बारे में अतिरिक्त जानकारी भी से प्राप्त की जा सकती है Mirror। देखें http://swiftdoc.org/v2.1/type/Mirror/ जानकारी के लिए।

— जोसफ भगवान
स्रोत
Stackoverflow.com/a/25345480/1187415 और stackoverflow.com/a/32087449/1187415 में क्या गलत है ? दोनों स्विफ्ट 2 के साथ काफी काम कर रहे हैं। (अन्य लोगों की जाँच नहीं की गई है।)
— मार्टिन आर
मैं इसे एक सामान्य समाधान के रूप में पसंद करता हूं, लेकिन "मिरर फॉर व्यूकंट्रोलर" (एक्सट्रॉनिक "मिरर फॉर") प्राप्त कर रहा हूं - रुको, यह ".subjectType" का उपयोग करने की तरह लगता है!
— डेविड एच
3

बीटा 5 के रूप में lldb में, आप कमांड के साथ किसी ऑब्जेक्ट की क्लास देख सकते हैं:

fr v -d r shipDate

जो कुछ इस तरह का उत्पादन करता है:

(DBSalesOrderShipDate_DBSalesOrderShipDate_ *) shipDate = 0x7f859940

विस्तारित कमांड का अर्थ कुछ इस प्रकार है:

Frame Variable (एक फ्रेम चर प्रिंट करें) -d run_target (गतिशील प्रकार का विस्तार करें)

यह जानने के लिए कुछ उपयोगी है कि आउटपुट वेरिएबल वैल्यूज़ के लिए "फ्रेम वेरिएबल" का उपयोग करने से कोई कोड निष्पादित नहीं होता है।

— केंडल हेल्मसटेटर गेलनर
स्रोत
3

मुझे स्व-विकसित वर्गों (या आपके पास इस तरह की पहुंच है) के लिए एक समाधान मिला है ।

अपनी वस्तुओं के वर्ग परिभाषा के भीतर निम्नलिखित गणना की हुई संपत्ति रखें :

var className: String? {
    return __FILE__.lastPathComponent.stringByDeletingPathExtension
}

अब आप बस क्लास का नाम अपनी वस्तु पर रख सकते हैं जैसे:

myObject.className

कृपया ध्यान दें कि यह केवल तभी काम करेगा जब आपकी कक्षा की परिभाषा फ़ाइल के भीतर बनाई गई हो, जिसका नाम ठीक उसी तरह रखा गया हो जैसा आप चाहते हैं।

जैसा कि आमतौर पर होता है , उपरोक्त उत्तर को अधिकांश मामलों के लिए करना चाहिए । लेकिन कुछ विशेष मामलों में आपको एक अलग समाधान निकालने की आवश्यकता हो सकती है।

यदि आपको कक्षा के भीतर वर्ग नाम की आवश्यकता है (फ़ाइल) तो आप केवल इस लाइन का उपयोग कर सकते हैं:

let className = __FILE__.lastPathComponent.stringByDeletingPathExtension

हो सकता है कि यह विधि कुछ लोगों को वहाँ से बाहर निकालने में मदद करे।

— Jeehut
स्रोत
3

ऊपर क्लास और केविन बॉलार्ड द्वारा दिए गए उत्तर और टिप्पणियों के आधार पर, मैं इसके साथ जाऊंगा:

println(_stdlib_getDemangledTypeName(now).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon?).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(soon!).componentsSeparatedByString(".").last!)

println(_stdlib_getDemangledTypeName(myvar0).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar1).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar2).componentsSeparatedByString(".").last!)
println(_stdlib_getDemangledTypeName(myvar3).componentsSeparatedByString(".").last!)

जो प्रिंट आउट लेगा:

"NSDate"
"ImplicitlyUnwrappedOptional"
"Optional"
"NSDate"

"NSString"
"PureSwiftClass"
"Int"
"Double"
— विंस ओ'सुल्लिवन
स्रोत
मुझे लगता है कि यह बेहतर जवाब है।
— मशाल
मैंने स्विफ्ट 1.2 का उपयोग करके निम्नलिखित को समाप्त किया: toString(self.dynamicType).componentsSeparatedByString(".").last!जाहिर है, मैं एक वस्तु संदर्भ में था और संदर्भ देने में सक्षम था self।
— जो
3 
let i: Int = 20


  func getTypeName(v: Any) -> String {
    let fullName = _stdlib_demangleName(_stdlib_getTypeName(i))
    if let range = fullName.rangeOfString(".") {
        return fullName.substringFromIndex(range.endIndex)
    }
    return fullName
}

println("Var type is \(getTypeName(i)) = \(i)")
— एलेक्स बुर्ला
स्रोत
3

स्विफ्ट संस्करण 4:

print("\(type(of: self)) ,\(#function)")
// within a function of a class

साभार @ जोशुआ डांस

— dengApro
स्रोत
3

स्विफ्ट 4:

// "TypeName"
func stringType(of some: Any) -> String {
    let string = (some is Any.Type) ? String(describing: some) : String(describing: type(of: some))
    return string
}

// "ModuleName.TypeName"
func fullStringType(of some: Any) -> String {
    let string = (some is Any.Type) ? String(reflecting: some) : String(reflecting: type(of: some))
    return string
}

उपयोग:

print(stringType(of: SomeClass()))     // "SomeClass"
print(stringType(of: SomeClass.self))  // "SomeClass"
print(stringType(of: String()))        // "String"
print(fullStringType(of: String()))    // "Swift.String"
— डेसमंड ह्यूम
स्रोत
2

प्रतीत होता है कि मनमाने मूल्य के प्रकार के नाम को मुद्रित करने के लिए कोई सामान्य तरीका नहीं है। जैसा कि अन्य लोगों ने उल्लेख किया है, वर्ग के लिए उदाहरणों के लिए आप प्रिंट कर सकते हैंvalue.className लेकिन आदिम मूल्यों के लिए यह प्रतीत होता है कि रनटाइम पर, प्रकार की जानकारी चली गई है।

उदाहरण के लिए, ऐसा लगता है कि टाइप करने का कोई तरीका नहीं है: 1.something()और Intकिसी भी मूल्य के लिए बाहर निकलो something। (आप, के रूप में एक और उत्तर का सुझाव दिया, उपयोग कर सकते हैं i.bridgeToObjectiveC().classNameआप एक संकेत देने के लिए है, लेकिन __NSCFNumberहै नहीं वास्तव में के प्रकारi -। सिर्फ यह क्या है जब यह एक ऑब्जेक्टिव-सी समारोह कॉल की सीमा को पार करने के लिए परिवर्तित किया जाएगा)

मुझे गलत साबित होने में खुशी होगी, लेकिन ऐसा लगता है कि प्रकार की जाँच सभी संकलन समय पर की जाती है, और सी ++ की तरह (आरटीटीआई अक्षम के साथ) प्रकार की अधिकांश जानकारी रनटाइम पर चली जाती है।

— ipmcc
स्रोत
क्या आप Xcode6 के खेल के मैदान में काम करने वाले मेरे उदाहरण में "अब" के लिए "NSDate" को प्रिंट करने के लिए className का उपयोग करने का एक उदाहरण दे सकते हैं? जहां तक ​​मैं बता सकता हूं, क्लासनेम को स्विफ्ट ऑब्जेक्ट्स पर परिभाषित नहीं किया गया है, यहां तक ​​कि उन जो NSObject के उपवर्ग हैं।
— मैट ब्रिजेस
ऐसा प्रतीत होता है कि 'क्लासनेम' उन वस्तुओं के लिए उपलब्ध है जो NSObject से उतरते हैं, लेकिन केवल मैक के लिए विकसित होने पर, iOS के लिए नहीं। प्रतीत होता है कि iOS के लिए बिल्कुल भी वर्कअराउंड नहीं है।
— मैट ब्रिज्स
1
हाँ, यहाँ वास्तविक टेकअवे ऐसा प्रतीत होता है कि, सामान्य स्थिति में, टाइप जानकारी स्विफ्ट में रनटाइम पर चली गई है।
— ipmcc
मैं उत्सुक हूं कि REPL मानों के प्रकारों को कैसे प्रिंट करने में सक्षम है।
— मैट ब्रिज
आरईपीएल की लगभग निश्चित रूप से व्याख्या की गई है और इसे संकलित नहीं किया गया है, जो इसे आसानी से समझाएगा
— ipmcc
2

यह है कि आपको अपनी वस्तु का एक प्रकार स्ट्रिंग मिलता है या प्रकार जो सुसंगत है और इस बात को ध्यान में रखता है कि वस्तु परिभाषा किस मॉड्यूल से संबंधित है या किसमें घोंसला बनाया गया है। स्विफ्ट 4.x में काम करता है।

@inline(__always) func typeString(for _type: Any.Type) -> String {
    return String(reflecting: type(of: _type))
}

@inline(__always) func typeString(for object: Any) -> String {
    return String(reflecting: type(of: type(of: object)))
}

struct Lol {
    struct Kek {}
}

// if you run this in playground the results will be something like
typeString(for: Lol.self)    //    __lldb_expr_74.Lol.Type
typeString(for: Lol())       //    __lldb_expr_74.Lol.Type
typeString(for: Lol.Kek.self)//    __lldb_expr_74.Lol.Kek.Type
typeString(for: Lol.Kek())   //    __lldb_expr_74.Lol.Kek.Type
— इगोर मुजक्का
स्रोत
2

स्विफ्ट में किसी प्रकार की वस्तु या वर्ग पाने के लिए , आप एक उपयोग करने की आवश्यकता चाहिए प्रकार (की: yourObject)

प्रकार (of: yourObject)

— राहुल पंजादे
स्रोत
1

ठीक नहीं कि आप क्या कर रहे हैं, लेकिन आप स्विफ्ट के खिलाफ चर के प्रकार को भी जांच सकते हैं जैसे:

let object: AnyObject = 1

if object is Int {
}
else if object is String {
}

उदाहरण के लिए।

— PersuitOfPerfection
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.