Можете ли вы перегружать операторы приведения типов в Swift? - PullRequest
Новая
       19

Можете ли вы перегружать операторы приведения типов в Swift?

0 голосов
/ 07 июня 2018

Я бы хотел реализовать автоматическое преобразование типов между известными типами в Swift.C # способ сделать это перегрузка операторов приведения типов.Если я хочу, чтобы мой тип X можно было взаимно назначать, скажем, с string, я бы написал: 

public class X 
{
     public static implicit operator string(X value)
     {
          return value.ToString();
     }

     public static implicit operator X(string value)
     {
          return new X(value);
     }
}

После этого я мог бы написать что-то вроде: 

string s = new X();
X myObj = s;

и они будут автоматически преобразованы.Возможно ли это как-нибудь в Swift?

1 Ответ

0 голосов
/ 08 июня 2018

Нет, язык не предоставляет такую ​​функциональность для пользовательских типов.Между коллекциями Objective-C и Swift существует мост, но он запекается и не настраивается.

// Swift array of `String` elements
let swiftArray: [String] = ["Bob", "John"] 

// Obj-C array of `NSString` elements, but element type information 
// is not known to the compiler, so it behaves like an opaque NSArray
let nsArray: NSArray = ["Kate", "Betty"] 

// Obj-C array of an `NSString` and an `NSNumber`, element type
// information is not known to the compiler
let heterogeneousNSArray: NSArray = ["World", 3]

// Casting with `as` is enough since we're going from Swift array to NSArray 
let castedNSArray: NSArray = swiftArray as NSArray

// Force casting with `as!` is required as element type information 
// of Obj-C array can not be known at compile time
let castedSwiftArray: [String] = nsArray as! [String]

// Obj-C arrays can not contain primitive data types and can only 
// contain objects, so we can cast with `as` without requiring a 
// force-cast with `!` if we want to cast to [AnyObject]
let heterogeneousCastedNSArray: [AnyObject] = heterogeneousNSArray as [AnyObject]

Документация для приведения типов доступна здесь .

Я думаю, вы можете добиться того, что вы хотите сделать с инициализаторами. 

extension X {
    init(string: String) {
        self = X(string)
    }        
}

extension String {
    init(x: X) {
        // toString is implemented elsewhere
        self = x.toString
    }        
}

let x = X()
let string = "Bobby"

let xFromString: X = X(string: string)
let stringFromX: String = String(x: x)

Не имеет прямого отношения к вашему вопросу, но есть также семейство протоколов, которые начинаются с ExpressibleBy..., что позволяет вам выполнять такие действия, как следующее: Допустим, мы хотим инициализировать строки из целочисленных литералов.Мы можем сделать это путем соответствия и реализации ExpressibleByIntegerLiteral 

// Strings can not be initialized directly from integer literals
let s1: String = 3 // Error: Can not convert value of type 'Int' to specified type 'String'

// Conform to `ExpressibleByIntegerLiteral` and implement it
extension String: ExpressibleByIntegerLiteral {
  public init(integerLiteral value: Int) {
    // String has an initializer that takes an Int, we can use that to 
    // create a string
    self = String(value)
  }
}

// No error, s2 is the string "4"
let s2: String = 4

Хороший вариант использования для ExpressibleByStringLiteral можно найти здесь .

...