タグ別アーカイブ: Swift

SwiftでQRコードを生成する

Core Imageを使うと簡単に作れるんですね〜
Swiftで実装するとこんな感じです。

func makeQRCodeImage(code:String) -> UIImage? {    
    guard let ciFilter = CIFilter(name: "CIQRCodeGenerator") else {
        return nil
    }
    ciFilter.setDefaults()
    
    // QRコードを設定
    ciFilter.setValue(code.data(using: String.Encoding.utf8), forKey: "inputMessage")
    
    // 誤り訂正レベルを設定
    // "L" "M" "H" が設定できるみたい
    ciFilter.setValue("M", forKey: "inputCorrectionLevel")
    
    if let outputImage = ciFilter.outputImage {        
    	// 作成されたQRコードのイメージが小さいので拡大する
        let sizeTransform = CGAffineTransform(scaleX: 10, y: 10)
        let zoomedCiImage = outputImage.applying(sizeTransform)
        return UIImage(ciImage: zoomedCiImage, scale: 1.0, orientation: .up)
    }
    
    return nil
}

ルビ付きのNSAttributedStringを使うとiOS8でBAD_ACCESSが発生する

原因としてはルビに空文字を設定してるのが悪いっぽい。

たとえばこんな感じ

// 空文字をルビとして設定する
let ruby = ""
var textRef: [Unmanaged<CFString>?] = [Unmanaged<CFString>.passRetained(ruby as CFString) as Unmanaged<CFString>, .none, .none, .none]
let annotation = CTRubyAnnotationCreate(.auto, .auto, 0.5, &textRef[0]!)
                
let attributedString = NSAttributedString(
                    string: "漢字",
                    attributes: [kCTRubyAnnotationAttributeName as String: annotation]

// ↓ ここでEXC_BAD_ACCESSが発生する
let line = CTLineCreateWithAttributedString(attributedString)

 

ほかにも

let framesetter = CTFramesetterCreateWithAttributedString( attributedText)

// ↓ ここでEXC_BAD_ACCESSが発生する
let frame = CTFramesetterCreateFrame(framesetter, CFRange(), path, nil)

ちなみにiOS10じゃ発生しないよ。

Swiftで青空文庫のルビをパースする

青空文庫のルビ表記をパースするサンプルを作ってみました。

青空文庫のルビはこんな感じで定義されてます。
http://www.aozora.gr.jp/KOSAKU/MANUAL_2.html

本来はリンクの通り、いろいろと細かな仕様があるのですが、今回はプログラムで「ルビ付き文字列を定義する」ということだけを狙ってシンプルな仕様で実装してみます。
具体的には↓のフォーマットだけを対象とします。

|漢字《よみかた》

例えばこんな感じですね。

「てめえらの|血《ち》は|何色《なにいろ》だーっ!!」

先に使い方ですが

let text = "てめえらの|血《ち》は|何色《なにいろ》だーっ!!"
let parser = AozoraRubyParser(text: text)
if let result = parser.parse() {
	for r in result {
		print("\(r.text) \( (r.ruby != nil) ? "[" + r.ruby! + "]" : "" )")
	}
}

こんな感じで出力されます
> てめえらの
> 血 [ち]
> は
> 何色 [なにいろ]
> だーっ!!

class AozoraRubyParser {
  
  class Result {
    let text:String
    let ruby:String?
    init(text:String,ruby:String?) {
      self.text = text
      self.ruby = ruby
    }
  }
  
  
  let text:String;  
  
  init(text:String) {
    self.text = text;
  }
    
  func parse() -> [Result]?{    
    
    var result:[Result] = []
    do {
  
      var position = 0;
      let nsText = text as NSString
      let totalLength = nsText.length
      
      let re = try NSRegularExpression(pattern: "|(.+?)《(.+?)》", options: [])
  
      let matches = re.matches(in: text, options: [], range: NSRange(location: 0, length: totalLength))
      for match in matches {
        let matchRange = match.range;
        
        // 現在の位置からrangeの先頭が離れていたら、その間の文字を抽出する
        if position < matchRange.location {
          let subRange = NSRange(location: position, length: matchRange.location - position)
          result.append(Result(text: nsText.substring(with:subRange), ruby: nil))
        }
        position = matchRange.location + matchRange.length;
	
        // 文字と読み仮名を抽出
        let str = nsText.substring(with: match.rangeAt(1))
        let ruby = nsText.substring(with: match.rangeAt(2))
        result.append(Result(text: str, ruby: ruby))
        
      }
      
      // 文末の残りを追加
      if totalLength > position {
        let subRange = NSRange(location: position, length: totalLength - position)
        result.append(Result(text: nsText.substring(with:subRange), ruby: nil))
      }
      
      
    }catch let err  {      
      log.error("\(err)")
      return nil;
    }
  
    return result
  }

}

Swiftで正規表現を使うサンプルとしてもどうぞ。

JSONパーサー Unbox をデータクラスを定義せずに使用する方法

Unboxは便利ですね〜
結構便利でswiftでjson扱う時はこればっかり使っています。
WEBで見てもユーザがどんどん増えている気がしますね。

さて、そんな便利なUnboxですが決まったデータクラスが存在しない時の扱いについてサンプルが少ないように感じました。
特にマップを要素に持つjson配列の扱いにちょっと迷いましたのでここにメモっておきます。

ポイントは performCustomUnboxing*** 系のメソッドを使う事と、 UnboxableDictionary を使う事です。



/*  
jsonStringには下記のjsonが入っているとして

{
   "storename":"金沢店",
   "stocks":[
      {"item":"白菜","stock":12},
      {"item":"甘エビ","stock":439}
   ]
}
*/

if let data = jsonString.dataUsingEncoding(NSUTF8StringEncoding) {           
  do {
                
    // performCustomUnboxing*** を使うのがポイント
                
    let result = try Unboxer.performCustomUnboxingWithData(data) { (unboxer) -> String in
                    
      // ルートの"storename"を取得
      let storename = unboxer.unbox("storename") ?? "unknown store"
                    
      // マップを含むjson配列はUnboxableDictionaryの配列として取得する
      let stockDictArray:[UnboxableDictionary] = unboxer.unbox("stocks")
                    
      // 取得したjson配列を performCustomUnboxingWithArray でパース
      let stocks = try Unboxer.performCustomUnboxingWithArray(stockDictArray) { (unboxer) -> (String,Int) in
                      
          let item = unboxer.unbox("item") ?? ""
          let stock = unboxer.unbox("stock") ?? 0
                        
          // 結果をtupleで返却
          return (item,stock)
      }
                    
      // パースした結果を文字列にして返却
      var caption = "storename:\(storename) \n"
      for stock in stocks {
        caption += " item:\(stock.0) stock:\(stock.1) \n"
      }
      return caption
    }
                
    print(result)
                
  } catch let error as NSError {
    print(error)
  }
}  

/*
[output]  
         
storename:金沢店  
item:白菜 stock:12  
item:甘エビ stock:439  
*/

MKMapViewのコンパスを移動させる

MapViewを回転(方角を変更)すると右上にコンパスが表示されます。
こんなの↓
20150727_1

右上に表示されるもんですから画面上部にツールバーをフロートで表示させようとした時などにとっても邪魔!
しかもこれ、iOS9だと消せるらしいのですがiOS8だと消せないんです(たぶん)。
で、移動させちゃえって思ったのですが、そんなプロパティ見つかりませんし、、

ただ、一部のアプリでは標準と違う場所に表示されているので何かしら方法があるのではないかと思って色々調べていたらstackoverflowでこんな情報が見つかりました。

http://stackoverflow.com/questions/18903808/ios7-compass-in-mapview-placing

簡単に説明すると

  • MKMapviewはUILayoutSupportが示す位置を参考にしてコンパスとか著作権情報などの表示位置を決めている。
  • で、このUILayoutSupportってのはViewControllerのtopLayoutGuideとかbottomLayoutGuideで決める事ができる。
  • なので、いい感じの位置情報を返すUILayoutSupportを、topLayoutGuideとかbottomLayoutGuideで返せばOK!

 
 
実際のコードはこんな感じで

最初に UILayoutSupport を実装したクラスを定義します

class MapLayoutGuide: NSObject,UILayoutSupport {
    
    private var _length:CGFloat = 0;
    
    init(length:CGFloat){
        super.init();
        _length = length;
    }
    
    var length: CGFloat {
        get {
            return _length
        }
    }

    @available(iOS 9.0, *)
    var topAnchor: NSLayoutYAxisAnchor {
        return NSLayoutYAxisAnchor()
    }
    
    @available(iOS 9.0, *)
    var bottomAnchor: NSLayoutYAxisAnchor {
        return NSLayoutYAxisAnchor()
    }

    @available(iOS 9.0, *)
    var heightAnchor: NSLayoutDimension {
        return NSLayoutDimension()
    }
}

で、これを ViewController の topLayoutGuide で返すようにオーバーライド

override var topLayoutGuide: UILayoutSupport {
   get {
      return MapLayoutGuide(length: 50);
    }
}

するとコンパスが下図のように移動してくれます。

20150727_2

(2015.09.15) iOS9向けのコードを追加しました

[Swift] Rangeの罠

RangeのendIndexと聞いてどのような意味を思い浮かべるでしょうか?
0から4のRangeはどの範囲を示しているでしょうか?

今回はRangeのendIndexについて説明します。

forループする時に下記のように記述すると思います

for i in 0..<4 {
  // 0〜3までループ
} 

この時 0..<4は Arange<Int>を示しており、下記のrangeと同じ意味です
let range = Range<Int>(start:0,end:4)
※ ちなみに 0…4であれば Range<Int>(start:0,end:5) です。

このrangeのstartIndexとendIndexを調べると下記のようにイニシャライザで指定した値がそのまま入っています。

println("range \(range.startIndex)〜\(range.endIndex) ")
// range 0〜4

もちろんこのように生成したrangeをfor-inでループしてもリテラルで宣言したものと同様に
処理されます。

for i in range {
  // 0〜3までループ
}

で、何が言いたいのかと言うと、、
endIndexが4ならループ変数 i が4まで実行させるべきではないかと。
そのほうが分かりやすいよね。
javaのString.substringのendIndexと同じって思えば良いんだけど、そもそもjavaのそれも気に入らないので。。

 

百歩ゆずってループで使う場合にはこの仕様で良いとシヨウ(仕様と掛かってます/ドヤ)
でも何かしらの範囲を示す場合に混乱しますよね。
例えばこのような関数があったとして

// ティーンエイジの範囲を求める
func teenagerRange() -> Range<Int> {
  // ティーンって13才から19才だよね
  return Range<Int>(start:13,end:19)
}

この関数の戻り値を使ってティーンエイジャーを列挙すると

for age in teenagerRange() {
  print("age \(age)")
}

・・13から18でループされる、ナインティーンどこいった?

 
 

んー、まぁ1万歩ゆずって整数ならまだ良しとしよう。
DoubleとかでもRangeを作れるので

let range = Range<Double>(start:0.0,end:1.0) 

この場合、最終の値はなに?
0.9? 0.999999?

→ ForwardIndexTypeに準拠しないためDoubleのRangeは使えなくなりました。

もちろん (range.startIndex <= X && X < range.endIndex) という条件が正の場合とすれば良いのは分かるし、
この仕様の方がフィットする型があるのもわかります。(日時とかね)
でも 0 〜 0.9(just)までを示す事が出来ないと思いませんか?

Rangeってからには範囲を示すもので汎用的に使いたいんですけど、なんか使いづらい!
というか、メソッドによってRangeの意味が変わってしまう気がして気持ち悪い!
上限値、下限値を範囲に含めるか否かを示す値があれば良いんだけど、これが無いからだよね。
これは要注意だよ!

(2014-07-11) XCode6.0-beta3での仕様変更を反映

[Swift] Sequence実装のサンプル(独自クラスのリスト)

SequenceTypeを実装することによって独自クラスをfor-inなどでループ処理することが可能になります。

 
SequenceTypeプロトコルは
func generate() -> GeneratorType
だけを実装すれば良いのですが、
今回のサンプルでは二分探索(バイナリサーチ)によるジェネリックスなSortedListを実装してみました。
 
 

使い方はこんな感じです

// イニシャライザで比較関数を渡す
// この例ではクロージャを使っています
let sortedList = SortedList<Int>(){
    (left:Int,right:Int)-> CompareResult in
        if (left == right) {
            return .Equal
        } else if (left > right) {
            return CompareResult.LeftLarge
        }
        else {
            return CompareResult.RightLarge
        }
    }

// 要素を追加
sortedList.append(7)
sortedList.append(5)
sortedList.append(3)

// 配列からも追加
sortedList.append([1,2,9])

// for-inループで要素を列挙
// Sequenceプロトコルが使われています
for elm in sortedList {    
	println("elm:\(elm)")
}
// 追加した要素がソートされて出力されます 1,2,3,5,7,9 


// 要素のインデックスを求める
if let idx = sortedList.indexOf(4) {
	println("found index=\(idx)")
} else {
	println("not found.")
}

 
 

以下ソース

// 要素の比較結果を示すEnum
enum CompareResult {
    case Equal,LeftLarge,RightLarge
}

// SortedListの実装
class SortedList<T>:SequenceType {
    
    // データの保存先 (実装されたらprotectedにするよ)
    var data = Array<T>()
    
    // 比較関数 (実装されたらprotectedにするよ)
    var compFunc:(left:T,right:T) -> CompareResult
    
    
    // イニシャライザ
    init(f:(left:T,right:T)-> CompareResult){
        self.compFunc = f
    }
    
    convenience init(_ initialData:Array<T>, f:(left:T,right:T)-> CompareResult){
        self.init(f:f)
        self.append(initialData)
    }
    
    // Sequence.generateの実装
    // これを実装することでfor-inで反復処理できるようになるよ
    func generate() -> IndexingGenerator<T[]> {
    	// Arrayの同機能を使って簡単に実装してますがカスタムについては後述
        return self.data.generate()
    }
    

    // ここからはArrayに実装されている機能を外にインターフェース

    subscript(index: Int) -> T {
        get {
            return data[index]
        }
        set {
            data[index] = newValue
        }
    }
    
    subscript(range: Range<Int>) -> ArraySlice<T> {
        get {
            return data[range]
        }
        set {
            data[range] = newValue
        }
    }
    
    // 要素を追加する
    // 追加されたIndexを返す
    // すでに同じ値が登録されていた場合にはNoneを返す
    func append(newElement:T) -> Int? {
        if (self.data.isEmpty){
            self.data += newElement
            return 0
        } else {
            let (hit,idx) =  _insertPos(newElement)
            if hit {
				// 上書きするのであればここで
                return .None
            } else {
                data.insert(newElement,atIndex:idx)
                return idx;
            }
        }
    }
    
    // 要素の一括登録
    func append(newElements:Array<T>) {
        let rate = self.data.isEmpty ? 1.0 : Double(newElements.count) / Double(self.data.count)
        if rate > 0.5 {
            //総量の5割を超えるレコードを追加する場合は一括でappendしてあとでソートする
            data += newElements
            _sortData();
            
        } else {
            self.data.reserveCapacity(self.data.count + newElements.count)
            for elm in newElements{
                self.append(elm)
            }
        }
    }    
    
    func append(newElements:SortedList<T>){
        self.append(newElements.array)
    }
    
    func removeAtIndex(index: Int) -> T {
        return data.removeAtIndex(index)
    }

    func removeLast() -> T {
        return data.removeLast()
    }
    
    func removeAll(keepCapacity: Bool = false) {
        data.removeAll(keepCapacity: keepCapacity)
    }
    
    // 要素を削除する
    // 戻り値:削除した要素のIndexを返す
    func remove(elm:T) -> Int? {
        let (hit,idx) =  _search(elm)
        if (hit){
            data.removeAtIndex(idx)
            return idx
        } else {
            return Optional.None
        }
    }

    var array:Array<T> {
        get{
            return self.data
        }
    }
    
    
    var count: Int {
    	get {
        	return data.count
    	}
    }
    
    var isEmpty: Bool {
    	get {
        	return data.isEmpty
    	}
    }
    
    var capacity: Int {
    	get {
        	return data.capacity
    	}
    }
    
    func reserveCapacity(minimumCapacity: Int) {
        data.reserveCapacity(minimumCapacity)
    }

    func filter(includeElement: (T) -> Bool) -> SortedList<T> {
        return SortedList(data.filter(includeElement),f:self.compFunc)
    }
    
    // (mapは比較関数も変わってしまうので実装しないことにしよう..)


    func reduce<U>(initial: U, combine: (U, T) -> U) -> U {
        return data.reduce(initial, combine)
    }
    

    // ここからは独自の機能
    
    // 指定された要素を検索してデータのインデックスを求める
    func indexOf(elm:T) -> Int? {
        let (hit,idx) =  _search(elm)
        return hit ? idx : Optional.None
    }
    
    
    // 指定したインデックスの範囲の要素をもったSortedListを返却する
    func sublist(range:Range<Int>) -> SortedList<T> {
        let subdata = data[range]
        return SortedList(Array(subdata),f:self.compFunc)
    }


 	// ここからはprivate or protectedにしたいな(実装されれば)
    
    
    // 要素の位置を検索する
    // 戻り値
    //  .0:存在したか
    //  .1:Hitした場所 or 近かった場所(前後のどちらか)
    func _search(elm:T) -> (Bool,Int) {
    
        var l = 0
        var r = self.data.count-1      
        
        while l < r {
            let m = (l + r) / 2;
            
            switch self.compFunc(left:elm,right:data[m]) {
            case .LeftLarge://右を探索
                l = m + 1
            case .RightLarge://左を探索
                r = m - 1
            case .Equal:
                return (true,m)
            }
        }
        
        if self.compFunc(left:elm,right:data[l]) == .Equal {
            return (true,l)
        } else {
            return (false,l)
        }
    }
    
    // 要素をインサートする場所を見つける
    func _insertPos(elm:T) -> (Bool,Int){
        
        let (hit,idx) =  _search(elm)
        if (hit) {
            return (hit,idx);
        }
        else {
            switch self.compFunc(left:elm,right:self.data[idx]) {
            case .LeftLarge:
                //追加する要素が大きい・・・idxの後にインサート
                return (false,idx+1)
            default:
                return (false,idx)
            }
        }
    }
    
    // 一括でソートする
    func _sortData() {
        sort(data){
            (o1 : T, o2 : T) -> Bool in
            return self.compFunc(left:o1,right:o2) == .RightLarge
        }
    }
}

C#のSortedListのように使用する場合にはジェネリックス型としてタプルを使えばよいかと。
 
 

今回行ったSequenceTypeプロトコルの実装はArrayの同機能を使って簡単に実装したのですが、カスタムしたい場合には下記のようにします。 
 
方法1. GeneratorOf を使う場合

// generateを下記のようにすればループする順序をカスタマイズできます
// ※カスタマイズしたらSortedListでは無くなってしまいますが。
func generate() -> GeneratorOf<T> {
    var index : Int = 0
    return GeneratorOf<T> {
        if (index < self.data.count){
            return self.data[index++]
        } else {
            return .None
        }
    }
}

 

方法2. 独自のGeneratorを実装する場合

// こんな感じでGeneratorを定義して
class SortedListGenerator<T> : Generator {
    let list : SortedList<T>
    var index : Int
    
    init(_ list: SortedList<T>) {
        self.list = list
        index = 0
    }
    
    mutating func next() -> T? {
        if index >= list.count { return .None }
        return list[index++]
    }
}

// 独自クラスのgenerate()でこのインスタンスを返すようにする
func generate() -> SortedListGenerator<T> {
    return SortedListGenerator(self)
}

 
 

今回のサンプルではSequenceTypeプロトコル以外の機能も実装したのでちょっと長いですが、
SequenceTypeプロトコル自体は簡単に実装できます。
独自クラスを反復処理する場合にはぜひ実装してみて下さい。

[Swift] 演算子のオーバーロード

Swiftでは演算子をオーバーロード可能です。

下記のクラスOkozukaiに幾つかの演算子を定義してみます。

// お小遣いクラス
class Okozukai {
    var okane = 0
    init(okane:Int){
        self.okane = okane
    }
}

 
C = A + B のような演算子を定義する時は @infix を付けて宣言します
※演算子のオーバーロードは全てFileスコープ(classとかの外側、グローバル)に宣言する必要があります。

// +(プラス)を宣言
func + (left: Okozukai, right: Okozukai) -> Okozukai {
    return Okozukai(okane: left.okane + right.okane)
}

// == と !=演算子 
func == (left: Okozukai, right: Okozukai) ->  Bool {
    return left.okane == right.okane
}
// != は明示的に宣言しなきゃダメみたい(==から逆判定はしてくれない)
func != (left: Okozukai, right: Okozukai) ->  Bool {
    return left.okane != right.okane
}

このように宣言すると下記のようにOkozukaiクラスが計算できます

let kozukaiA = Okozukai(okane:1000)
let kozukaiB = Okozukai(okane:2000)

var kozukaiC = kozukaiA + kozukaiB

if (kozukaiC == Okozukai(okane:3000)){
   NSLog("kozukaiCは3000円")
}

 

A += B のような演算子を定義する時は @assignment を付けて宣言します
第1引数がinoutなので注意

// "+="を宣言
func += (inout left: Okozukai, right: Okozukai) {
    left = left + right
}
// オーバーロードも出来る
func += (inout left: Okozukai, right: Int) {
    left = left + Okozukai(okane:right)
}

let kozukaiA = Okozukai(okane:1000)
kozukaiA += 1000
kozukaiA += Okozukai(okane:500)
NSLog("小遣い:\(kozukaiA.okane)")
// 小遣い:2500

 

prefixを指定すると -a のような演算子を宣言できます。
※同様に postfixだと a- のような演算子

prefix func - (oz:Okozukai) -> Okozukai{
    return Okozukai(okane:oz.okane * -1)
}

let kozukaiA = Okozukai(okane:1000)
let minusOkozukai = -kozukaiA
NSLog("小遣い:\(minusOkozukai.okane)")
// 小遣い:-1000

 

++a のような自身に対しての演算を行う場合

prefix func ++ (inout okozukai:Okozukai) -> Okozukai{
    okozukai.okane += 1000
    return okozukai
}

let kozukaiA = Okozukai(okane:1000)
++kozukaiA
NSLog("小遣い:\(kozukaiA.okane)")
// 小遣い:2000

(2014-08-26) beta5で色々変わっていたのでサンプルコードを修正

[Swift] クロージャ(Closures)のサンプル

objective-cのblocksに変わるものとしてSwiftではモダンなクロージャが導入されています。

 

簡単な例から


var closure = {(valueMap:Dictionary<String,Int>) -> Int in
    var total = 0
    for p in valueMap.values {
        total += p
    }
    return total
}

解説すると
dictionary を引数として Int を返すクロージャを宣言して 変数”closure”に格納しています。
なんだか構文がややこしいように見えますが”in”の前にパラメータ・戻り値、”in”の後に実装を書き、全体を{・・・}で囲っているだけです。
こんな構造
{ (引数) -> (戻り値) in
//実装
}
blocksに比べると随分と分かりやすい構文だと思います。

この変数に格納されたクロージャを使うときは


var populationDict:Dictionary<String,Int>  = [
    "kanazawa":10,
    "komatsu":100000,
    "nanao":50000
]

let population = closure(populationDict)

このように普通の関数呼び出しと同様に使えます。

 
 

呼び出し時にメソッドの型をコンパイラが分かっていたら
こんな感じでパラメータ、戻り値を省略してクロージャを記述できる


// クロージャを受け取る関数を宣言
func logCalcResult(calcFunc:(Double,Double) -> Double ,v1:Double,v2:Double) {
    // v1,v2をパラメータとして受け取った関数(calcFunc)を実行
    let calcResult = calcFunc(v1,v2)
    NSLog("calcResult \(calcResult)")
}

// パラメータ、戻り値を省略したクロージャをインラインで宣言してます
// ※{・・・}の部分
// 引き渡されるパラメータ $0、$1、・・・ って名前で参照
logCalcResult({ return $0 + $1} ,20 ,30)

 

trailing closure って機能も使えます
関数の最後のパラメータがクロージャだった時、引数ブロックの外側にブロックを宣言してクロージャを渡せる
(説明がわかりにくい!)


// こんなclosureを受け取る関数があったとして
func logText(closure:() -> String){
    NSLog(closure())
}

// 呼び出しの "()"の外側に { ... } を宣言してクロージャとして渡せる
logText(){
    return "trailing クロージャ!!"
}

上手く使うとカッコ良くかけますね。
 
 

クロージャなので”Capturing Values”も行われます。
※要するにクロージャが宣言された”環境”への参照をクロージャが保持しちゃう機能

たとえばこんな感じでクロージャを返す関数を用意して


// 月から日までを列挙するクロージャを返す関数
func weekNameEnumBuilder() -> () -> String {
    var weekday = -1
    let names = ["月","火","水","木","金","土","日"]
    
    return { () -> String in
    	//キャプチャしたweekdayをクロージャ内でインクリメント
        weekday++
        if (weekday == names.count) {
            weekday = 0
        }
        return names[weekday]
    }

}

このように実行するとweekdayがキャプチャされている事がわかりますね。


//キャプチャする値はweekNameEnumBuilderの実行時に個別に取得される。
//下記のように2回呼び出すとそれぞれ別の変数(weekday)をキャプチャしていることが分かる
let weekNamesA = weekNameEnumBuilder()
let weekNamesB = weekNameEnumBuilder()

NSLog("Capturing A-1: %@" , weekNamesA())
NSLog("Capturing A-2: %@" , weekNamesA())
NSLog("Capturing B-1: %@" , weekNamesB())
NSLog("Capturing B-2: %@" , weekNamesB())
NSLog("Capturing A-3: %@" , weekNamesA())
//  Capturing A-1: 月
//  Capturing A-2: 火
//  Capturing B-1: 月
//  Capturing B-2: 火
//  Capturing A-3: 水

 
  

注意しなければならない事が1点。
クロージャー内でselfとかの参照をしてしまうと selfからクロージャーへの参照とクロージャーからselfへの参照が発生し、循環参照となってしまうというobjective-cではおなじみの現象がswiftでも発生します。
この問題への解決方法としてもobjective-cと同じように弱参照を行うことになるのですが、Swiftのクロージャではキャプチャリスト(Capture List)という形でクロージャ宣言の直前にキャプチャする対象の参照方式を指定することができます。

下記サンプルの [unowned self] ってのがそれで、selfをunownedで参照するように指定しています。


class Doraemon {
    
    var poket = Dictionary<String,AnyObject>()
    
    init(){
        poket["タケコプター"] = "Takekoputer 9-inch,Late 2013"
    }

    // 引数にstringを受け取り、stringを返すクロージャを生成・返却する
    func checkPocket() -> (String) -> String {
    
        return {
            // キャプチャリストは  [参照方式 対象,参照方式 対象 ・・・] という形で記述する
            // この例では self を unowned で参照
            [unowned self] (itemname:String) -> String in
            
            if self.poket[itemname] {
                return "\(itemname)は持ってるよ。僕ドラえもん。"
            } else {
                return "\(itemname)は今修理中。"
            }
        }
    }
}

    
let dora = Doraemon()
let checkPocket = dora.checkPocket()
NSLog(checkPocket("どこでもドア"))
NSLog(checkPocket("タケコプター"))
// どこでもドアは今修理中。
// タケコプターは持ってるよ。僕ドラえもん。

 
 
 
あと、クロージャや関数を変数に格納する場合が多々あると思います。
その宣言方法をメモっておきます。

// クロージャ、関数を変数に格納する場合の宣言
var funcA:(String) -> (String)

funcA = {
    (a:String) -> String in
    return "hello \(a)"
}

// 実行
funcA("マサオ")


// オプショナル(Optional)だった場合
// 全体をカッコで囲ってオプショナルの指定を行う
var funcB:((String) -> (String))?

funcB = {
    (b:String) -> String in
    return "hello \(b)"
}

// 実行する時はこんな感じ
funcB!("タテオ")


// 戻り値が無かった場合
var funcC:(String) -> ()

funcC = {
    (c:String) in
    println("hello \(c)")
}

funcC("ヒロシ")

[Swift] ジェネリックス(Generics)のサンプル

objective-cで何で使えないんだよ、、、と常々思っていたGenericsもSwiftではもちろん使えます。
最近の開発言語では当たり前の機能ですね。

 

ジェネリックスな関数のサンプル

// 引数で与えられた要素を持ったSwift配列を返す
func toArray<T>(values:T...) -> Array<T> {
    var result = Array<T>()
    for v in values {
        result += v
    }
    return result
}


// こんなふうに呼び出すことが可能
// うーん、ジェネリックス!
let intArray = toArray(1,2,3,4,5,6,7)
let stringArray = toArray("A","B","C")

 
 

ジェネリックスなクラスのサンプル

// IntをキーとしたDictionaryを生成するBuilderクラス
// appendで要素を追加してbuildで作成
class IndexedDictionaryBuilder<T> {
    
    var array = Array<T>()
    
    func append(elm:T){
        array.append(elm)
    }
    
    func build() -> Dictionary<Int,T> {
        var result = Dictionary<Int,T>()
        for (index,elm) in enumerate(array) {
            result[index] = elm
        }
        return result
    }
}


// 使い方
// コンストラクタで型を指定
let builder = IndexedDictionaryBuilder<String>()
builder.append("アガシジィ")
builder.append("ビタエニアータ")
builder.append("エリザベサエ")

// buildするとコンストラクタで指定した型を値に持ったdictionaryを生成する    
let dict:Dictionary<Int,String> = builder.build()
for (key,value) in dict {
    NSLog("第\(key)位 \(value)")
}
// 第1位 アガシジィ
// 第2位 ビタエニアータ
// 第3位 エリザベサエ

 
構文も素直で使いやすいですね。