DevQiao

Interaction Design & Collaborative VR

2017-04-16T16:21:20+00:00

To discover more possibilities in interaction design field, we try to combine different advanced device as mush as we can, to create a realistic experience, even beyond reality, and make the interaction process smoothly.

An idea hexagon - Solution-driven approach

Finding the neXt

The hexagon provide a systematic way to generate many unique solutions

Three principles

Start with something new, interesting, never seen before.
Iterate quick. by looking for variations of solutions and problems.
Give up soutions quick.

An example of the creative ideas when using camera

Rotoscoping

An animation technique in which animators trace over footage, frame by frame, for use in live-action and animated movies.

360 Camera

OSC(Open Sound Control)

Arduino integration

vibration actuator

Leap Motion

Integrated into VR

Floor Projection

Calibration

This transformation is called an extrinsic matrix(外部矩阵) of a camera. This operation is also called homographic transformation(单应变换). 点我参考

Our Project - One Piece in Collaborative VR

Flow chart

Lo-Fi

TRX Room Setting & Hi-Fi

Final Demo

Finally, we invited our classmates to try our creation which bring a brand new experience.

Team members

FatRes - A solution for the sedentary lifestyle

2017-01-10T10:57:16+00:00

Using the “User-centered Interaction Design Process”, this project aim to design a meaningful system to ease the specific people’s sedentary lifestyle.

Problem

Sedentary lifestyle will lead people in the state of sub-health prematurely, and sitting for a long time will become fat.

Target Population

Researchers / graduated students, who have sedentary lifestyles

They read paper for a long time
Can flexibly control their time

Importance

Sedentarism and Obesity can cause Cardiovascular diseases

Sedentarism would form a vicious cycle

Sedentary lifestyle -> Obesity -> Lazy -> Low efficiency -> Sit for longer time -> Sedentary lifestyle

Stakeholders

Researcher themselves would be healthier
boss love efficient researchers

Interview - Understanding Users

How we recruited interviewees?

We find people who are in the same laboratory or friends.
We totally recruited 18 interviewees.
Most of them are researchers, and only 2 interviewees are engineers.

Themes of our questions

Why did you sit for such a long time then?
- What interrupt you then?
  - What did you do after the interruption?
  - Why did you do that?
Do you know what and how sedentary lifestyle affect you?
- Do you know how to avoid sedentary lifestyle?
  - If you don’t know, please come out a method right away.
- What kind of method did you use to avoid sedentary lifestyle?
  - Why did you choose that method?
- Did you success?
  - Yes: Why did you keep using this method?
    - Would you recommand this method to others?
    - How would you recommand it?
  - No: Why can’t you keep using this method?
    - What problem did you face?
What’s your favorite leisure activity?
- Is this activity need to be done while sitting?
- Can you do this activity without sitting for a long time?
- Is there any other leisure activity that need not be done while sitting?

Model

What models did we create and use

We used the sequencial model

Primary Intent: Using the computer to make ppt or write papers

Trigger: When they are at lab and need to work

Breakdown: They need to drink water or go to bathroom

Step:

Affinity wall - Data Interpretation

lowest layer
higher layers

Key findings & highlights

Red Tag:

The top is that by interrupting the current behavior,interviewees can not only avoid sedentarism but can also increase their working efficiency and concentration.

Green Tags:

When doing leisure activities, interviewees can be sitting (browsing FB, playing LOL, or watching movies), or not (going out for a walk with friends or exercising).

Interviewees can avoid sedentary lifestyle by drinking water, going to the restroom, or eating and so on, but can not form the habit of standing up.

Concentrating on doing something in the suitable environment leads interviewees to sedentary for more than two hours.

Personas

Method

We created 4 personas based on our interview data
We compared the personas and chose some valuable behavior variables and remove the other less valuable ones
We merged the personas into 3 final personas based on their behavior variable distributions

Behavior Variables and Distribution

We use the following attributes to create 7 behavior variables

Activity:

He sits in a chair for almost all day long
Sometimes he stands up and walks to bathroom
Sometimes he stands up and walks to drink some water
He plays games while sitting for an hour
He watches videos on Youtube while sitting for half an hour
He makes ppt while sitting for 2 hours
He prepares enough water before working so that he doesn’t need to stand up to get some water

Attitude:

He knows the disadvantages of sedentary lifestyle, but he is too lazy to stand up
He doesn’t like to go outside
He doesn’t like to stand up for more than half an hour
He wants to concentrate on his work
He doesn’t like to do leisure activities while standing up
He doesn’t have the habit to stand up, so he can’t change the sedentary lifestyle
He wants to concentrate on his work so he doesn’t stand up
He is too lazy to stand up

Motivation:

He wants to become healthier
He wants to concentrate on his work more

Finally, we got 7 behavior variables and their distribution

Sitting time (short – long)
Standing up reason (physical – mental)
Leisure activity (sitting – standing)
Danger of sedentism (don’t know – know)
Outgoing (no – yes)
Stand up frequency (low – high)
Personality (lazy – hardworking)

Finally results of personas

Scenarios

We design a game, FatRes. Players have to walk around to complete missions. The stamina is recovered every 30 minutes with ringing or vibration on the phone.

Method

We came out with several situations
Choose one situation that matches with persona
Set up the timing of the events
Write down the details of what persona does to complete the scenario

Finally results of scenarios

Scenario #1

As usual, after arriving at his laboratory the first action Kevin takes is sitting on his seat, and then logs in FatRes not only to turn his mind to work but also to get daily reward. The next schedule showing on FatRes is time for teaching assistants. Because he was appointed as a curricular tutor for this semester, he has responsibility to stay here for following two hours to give a response to any student who has questions. Kevin opens the paper and continues reading from where he marked yesterday. Until FatRes rings to remind Kevin of that his stamina on the app is recovered, he leaves to the pantry room with his cup to fill it with water. On the way, he feels glad about his cumulative achievements. Upon getting back on his seat, he pays attention on paper until there are two students ask him about homework. Before answering their questions, he turns his phone to vibration mode. While their discussion, no one notices the vibration. Until those two students leave, Kevin notices tips from FatRes and stands up suddenly to answer the following question. Before lunch, he keeps what he does as usual, going to the staff room upon receiving the tips from FatRes, or sometimes going around to the restroom. Afternoon the FatRes reminds Kevin when one hour earlier than he has an agreement with his classmates to play badminton, he start stretching to warm up before today’s last breakdown .

Scenario #2

John walks to his lab and sits in the chair in the morning. He puts his bag on the table and takes out his phone and breakfast. He opens FatRes game in his phone and takes it out with breakfast. FatRes shows that the next chapter of the story is two miles away, so John walks to the place with FatRes’ guide. After reading the latest chapter of story and finishing his breakfast, John walks back to his lab. He puts the phone on the table and sits in the chair. He opens the computer and start programming for two hours. After completing several functions, John decides to take a break and open his phone. The notification of FatRes is showing in the front page, which notices John that there is new chapter of the story available. So John take out his phone and water bottle to read the next chapter and drink some water by the way. With FatRes, John has more motivation to stand up and walk around than before.

Scenario #3

Because today is a holiday,Peter opens his computer to watch a movie.He has run out of stamina that there is in the FatRes game.After 30 minutes, his phone rings.He finds that there is enough stamina for playing games.He stands up to fill his cup with water and go to the bathroom.He goes back to watch the movie again.After 30 minutes, his phone rings again.Peter plays the FatRes games.By the way,Peter doesn’t sit down in front of the computer for a long time, and he can stand up regularly.

Brainstroming & Sketching

Original Design

The game will inform the player to stand up periodically and can get points based on how long he stands up, and he can use them to exchange some coupons
The game is a story book. Player should move around to unlock next chapter of the story
Player should walk around to save the animals in the virtual world. They can change the scenes when reaching some goals
FatRes is a scheduling tool that reminds user to stand up

Feature Selection

We considered that some users need to work for a continuous period, so we gave up the periodical notification.
We like the idea of gathering points and exchanging for something, so we remain this feature and separate it into standing and walking parts.
We turned the coupons into stories, clothes, background and music.
We turned the idea of changing scenes into traveling cities in the virtual world, and the items in 3 will present the culture of each city the player visits.

Lo-Fi Prototype

FatRes Lo-Fi Prototype Description

Player should stand up to get Money (10 gold/min).
Player should walk outside the Home to get Distance (1m in game = 1m in real). Walking outside the home will cost stamina (1%/m). Without the stamina, player can not get Distance anymore. Staying in the home will restore the stamina (1%/min).
Traveling to other city would cost some Distance.
Player can buy stories, clothes, background, background music in store. And these items are related to the city’s culture.
Player can decorate his avatar in bag scene.
There are two version of stories, normal version and special version. Player can buy all pieces of normal version stories in FatRes. However, player can only buy one piece of special version story of each city, which is random chapter and not knowing total number of chapters. We encourage players to share and discuss their special version stories to the other players.

Feedbacks & Design Changes

In the last milestone, we proposed a prototype as a game. We wanted to use the game to encourage users to stand up and walk around. However, we faced several issues:

It was too similar to Pokemon Go -> Little value for designing another game for walking
Not everyone like to play games -> Narrowed down our target users
Users may give up playing the game because of laziness -> Lazy is a big boss

We tried to use physical feedback to solve the issues.

Everyone needs to drink water
No one hates drinking water
No one gives up drinking water

So we came up with a new design, Smart Cup. We want to increase the amount of water the user drinks so that they would have to get up and go to the bathroom more frequently. Finally, we hope the user can form a habit of drinking water and going to the bathroom and hence get rid of sedentary lifestyle.

Key Task

Remind the user to drink water periodically when the user is not busy
Remind the user to stand up and refill the cup with water
Let user’s body to inform him/her to go to bathroom

Design Details

Detection

The cup will detect whether the user is busy or not. If the user is busy, the cup will not notify the user until he/she switches to less important task. If the user is not busy, the cup will notify the user to drink some water every 18 minutes. User can determine the period length

Notification

The notification has 2 modes, vocal and vibration a. The user can select the mode he/she wants to use b. The system will detect the environment and decide which mode is better to use. In the vocal mode, the cup will tell the user to drink some water with hierarchical emotional words. For the first time, the cup will tell the user, “it is time to drink some water.” If the user doesn’t drink the water in 30 seconds, the cup will say, “drinking water is good to your health”, “if you don’t drink water, you will get fat!”, “drink it you such a pig!”, separately every 30 seconds. In the vibration mode, the cup will vibrate to notify the user to drink some water. Similar to vocal mode, the cup will vibrate in a hierarchical pattern. It will vibrate once, twice, 5 times, 5 double vibrates, and continuous vibration separately every 30 seconds. User should drink at least 100ml or all the water in the cup to turn off the notification.

Refill

If the user does not refill the cup after drinking within 2 minutes on the plate, the cup will notify the user to refill it by turning the color of the cup into red. When the user pulls water into the cup, the cup will display how much water in the cup by changing the color outside. If the water level is over the threshold, the cup will beep once to notify the user. Once the cup is put onto the coaster, it starts to count down and detect the user’s state.

Coupon

The user can get one point every time he/she drinks, i.e. drinking 100ml for one point. The user can go to the coupon exchange website via the QR code.

Hi-Fi Prototype

Smart Cup is a system that can remind user to drink some water periodically and when the user is not busy. We want to use the behavior of refilling and going to bathroom to increase the chance the user stands up.

Usability Test

Goal

We want to know how our Smart Cup influence the participants’ feeling and efficiency while working or playing, and whether Smart Cup can really solve the sedentary problem.

Participant Recruitment

We recruited our friends as our participants because they are sedentary researchers, which is our target group. We totally recruited 5 participants.

Test Setting

We went to participant’s lab or the place he/she likes to work/stay in. We asked the participant to prepare a cup or bottle as a substitution of the Smart Cup, and we researchers pretended the notifier of the Smart Cup.

Task Procedure

We described the function of the Smart Cup and our purpose. Participants were instructed to drink some water every 10 minutes, and we would notify them so they didn’t need to worry about it was time up or not. We chose 10 minutes as a period because we don’t want to last the experiment too long.

There are 2 factors in our usability test, situation (working or playing) and task (drink or drink+refill). All participants had to do the tasks of all the conditions. The order of situation is counterbalanced, more specifically, 2 participants started with playing, and 3 participants started with working. The task was in fixed order: drink, drink + refill, drink, drink + refill. This order is simplified but similar to our real drinking behavior.

Data Collection

After the test, we interviewed the participants about how they feel about the product and the test, and what problem they faced. Also, how the Smart Cup influences their drinking behavior and sedentary lifestyle.

Findings

Participants usually refill the cup and go to bathroom at the same time they stand up. Although this may reduce the chance for participants to stand up, we think it can still help participants getting out of sedentary lifestyle.
Most participants reported that the Smart Cup can increase the amount of water they drink and the chance to stand up.
Most participants reported that they were bothered when Smart Cup interrupted their work or play. Some reported that they can’t continue their reading smoothly after the interruption. Some reported that they lost some immersion of playing games when interrupted. As previously mentioned, we set 10 minutes as a period because of experiment time, so we didn’t detect the break point of participants. It turns out that detecting break point of the participant is an important feature.

Improvement

Based on the usability test, we discussed and came out with the following improvements:

Improve break point detection. Previously, we only detect whether the user is switching applications or not as a break point. Now we also add the detection of finishing coding of a function, and finishing reading/writing of a paragraph detected by eye-tracker to our break point detect.
Customizable water consumption. User can decide how much he/she should drink every time, but it should not be lower than 30ml.
Forced notification. If we still can not detect the break point for over an hour, we will notify the user to drink some water no matter how busy the user is. The reason is that we don’t want the user to be too busy to drink water, and that would have no difference from without using Smart Cup. Although the forced notification would bother the user every hour in the worst case, we think getting rid of sedentary lifestyle is more important, and so we add this feature to our system.
Remove color changing. We think the user do not need to know how much water remained in the cup. If the cup is empty, the system will inform the user via speech or vibration.
Coupon exchange button. We change the QR code to a button that can directly access to the website via the browser in user’s computer.

Summary

Smart Cup has the following features:

Customizable period of water drinking notification countdown.
Customizable required consumption.
Break point detection.
Speech/vibration mode
Point collection and coupon exchange.

Final Poster

Exhibition

Stack in Swift

2016-06-15T12:04:29+00:00

栈像是一个有限功能的数组，你只可以通过’push’在栈顶添加一个新的元素，用 pop 从栈顶移除这个元素，同时 peek (一瞥)栈顶元素而不弹出（意为只能对栈顶元素执行存取操作）。

为什么我们需要这么做？在很多算法中你想将一个元素加入到一个临时列表里，与此同时你希望稍后将它们拉去出来，通常你添加或删除这些元素的顺序是被关心的问题。

栈结构给了你一个后进先出的顺序（ LIFO ）即 last-in first-out 。你最后一个push进去的元素就是你在下一次第一个pop出来的元素。（另一个比较相似的结构是 队列（queue） ，它是FIFO先进先出的。）

举个栗子，以下代码将一个数字’push’到栈中：

    stack.push(10)

现在，当前栈是[10]。接下来在push下一个数字：

  	  stack.push(3)

当前栈变为[10， 3]。再push一个新的数字：

	  stack.push(57)

当前栈是[10, 3, 57]。让我们弹出栈顶元素：

	  stack.pop()

这会返回57，因为它是我们最后一次被push的，现在栈的状态又变回了[10，3]

	  stack.pop()

这将继续返回3。如果栈为空，pop动作返回nil，再另一些实现方式里会抛出错误信息(“stack underflow”)。

在Swift中，栈很容易被创建。它只是数组的包装。 public struct Stack { fileprivate var array = [T]()

  public var isEmpty: Bool {
    return array.isEmpty
  }

  public var count: Int {
    return array.count
  }

  public mutating func push(_ element: T) {
    array.append(element)
  }

  public mutating func pop() -> T? {
    return array.popLast()
  }

  public func peek() -> T? {
    return array.last
  }
}

注意push将元素放在数组尾部而不是开始，在数组开头插入元素代价很大，复杂度是 O(n) ，因为这需要在内存中移动数组中的所有元素。而在尾部添加的复杂度为 O(1) ；栈总是花费相同的时间，而无视数组大小或规模（我认为是稳定性）。

一个有趣的事实是：每次你调用一个方法或者函数，CPU会将返回地址放入一个栈。当函数结束，CPU使用这个返回地址跳回调用者。这就是为什么如果你调用太多函数—例如永不结束的递归函数—你得到一个所谓的栈溢出（stack overflow）错误，原因是CPU栈空间已被用尽。

Swift基础语法（五）

2016-05-17T15:24:00+00:00

本篇作为Swift的第四篇，主要介绍了Swift中的枚举类型，它和其它语言相比有其特殊性

本篇作为Swift的第四篇，主要简述Swift中的属性、方法

属性（Properties）

Properties are variables and constants that comprise the attributes of a named type.

可存储属性（stored properties）

这些属性为每一个实例分配内存，存储其真实的值

只有类和结构体可以有stored properties

  //Contact有两个存储属性
  struct Contact {
    var fullName: String
    var emailAddress: String
  }

  //Swift会根据你定义的属性自动创建一个初始化器
   var person = Contact(fullName: "乔黎博",
   emailAddress: "qiaolibo@yeah.net")

   //用点语法存取每个属性
    let name = person.fullName
    let email = person.emailAddress

    person.fullName = "Qiao"

默认值（Default values）

属性可以设置默认值

自动合成的初始化器不会包含默认值，除非你自己声明自己的初始化器

  enum Type {
    case Work, Family, Friend
  }
  struct Contact {
    var fullName: String
    let emailAddress: String
    var type: Type = .Friend
  }

可计算属性（computed properties）

这些属性没有为他们实际分配内存，它不存储任何值，而是在 每次存取 的时候被计算出来，然后返回一个值
类、结构体和枚举都可以有computed properties
计算属性赋值用花括号（{}）里的代码段取代等号（=）

存取计算属性和存取存储属性类似

    //电视尺寸的结构体
    struct TV {
      var height: Double
      var width: Double
      // 计算属性
      var diagonal: Int {

        let aSquared = pow(height, 2)
        let bSquared = pow(width, 2)
        let cSquared = aSquared + bSquared

        let c = sqrt(cSquared)
        // 四舍五入，直接转Int会截断
        let rounded = round(c)

        return Int(rounded)
      }
    }

   var tv = TV(height: 53.93, width: 95.87)
   let size = tv.diagonal

Getter和Setter

如果想要定义setter，则getter必须显示声明，以便区分那个是getter，哪个是setter
setter没有地方存值，因此它间接设置存储属性（stored properties）

newValue 关键字代表在赋值时传入的数据

  var diagonal: Int {

    get {
        return Int(round(sqrt(height * height + width * width)))
      }

    //每次设置diagonal时，都会计算并存储height和width
    set {
        // 默认值
        let ratioWidth: Double = 16
        let ratioHeight: Double = 9
        // 计算结束后，高度和宽度属性被赋值
        height = Double(newValue) * ratioHeight / sqrt(ratioWidth * ratioWidth + ratioHeight * ratioHeight)
        width = height * ratioWidth / ratioHeight
      }
  }

  tv.diagonal = 70
  let height = tv.height // 34.32...
  let width = tv.width // 61.01...

类型属性（Type properties）

以上属性在每一个实例的属性都是分离的，也就是每一个实例都有各自的属性值，但是在需要这些实例之间共同的属性时就需要Type properties（type itself may also need properties that are common across all instances）

在值类型（value-based types like structures）前使用 static 关键字声明一个Type properties

  //游戏关卡的例子，每一关不同状态
  struct Level {
    static var highestLevel = 1
    let id: Int
    var boss: String
    var unlocked: Bool
  }
  let level1 = Level(id: 1, boss: "Chameleon", unlocked: true)
  let level2 = Level(id: 2, boss: "Squid", unlocked: false)
  let level3 = Level(id: 3, boss: "Chupacabra", unlocked: false)
  let level4 = Level(id: 4, boss: "Yeti", unlocked: false)

  //存取
  let highestLevel = level3.highestLevel //错误，类型属性不应在实例上存取
  let highestLevel = Level.highestLevel  //1

单例模式（Singleton pattern）

Using Singleton is a powerful way to share data between different parts of your code without having to pass the data around manually.

一种实现单例的方法是使用常类型属性 static let

必须将单例声明为引用类型，而不是值类型。声明为值类型将不能改变里面的属性

  //You must declare a singleton as a reference-type class rather than a value-type structure.
  //If you were to implement one as a structure, then you wouldn't be able to change the values of gameScore and saveState later because the defaultManager property is a constant.
  //When you declare GameManager as a class, only its address in memory is a constant rather than the values themselves.
  // You can change the values of gameScore and saveState since GameManager is a reference-type class.
  class GameManager {
    static let defaultManager = GameManager() //默认值值一个新的GameManager实例
    var gameScore = 0
    var saveState = 0
    // 私有初始化意味着类实例只被初始化一次，在外部没有其他方法对其初始化
    private init() {}
  }

属性观察（Property observers）

a way to listen to property changes

属性监听器（property observers）：willSet {} 会在属性变化之前调用，didSet {} 会在属性变化之后调用，用法和 set {} get {} 类似

willSet {} 和 didSet {}不会在初始化过程中调用，只有当你对一个初始化过的实例赋新值时才会调用，这意味着property observers只会用在可变属性（variable properties），因为常量属性（constant properties）只会在初始化过程中被置值

    struct Level {
    static var highestLevel = 1
    let id: Int
    var boss: String
    var unlocked: Bool {
      didSet {
        //可以在didSet{}的实现中使用unlocked
        //即使已经在类型里了，也必须写全名：Level.highestLevel而不是highestLevel
        //unlocked是存储属性而不是计算属性，因为没有提供 get {}
        if unlocked && id > Level.highestLevel {
          Level.highestLevel = id
        }
      }
    }
  }

限制变量（Limiting a variable）

可以在 willSet 中使用 newValue，在 didSet 中使用 oldValue

//if the current flowing into the bulb exceeds the maximum value, it will revert to its last successful value.
//Notice there's a helpful oldValue constant available in didSet {} so you can access the previous value
class LightBulb {
  static let maxCurrent = 40
  var currentCurrent = 0 {
    didSet {
      if currentCurrent > LightBulb.maxCurrent {
        print("Current too high, falling back to previous setting.")
        currentCurrent = oldValue
      }
    }
  }
}

延迟加载属性（lazy stored property）

The lazy keyword prevents a value of a stored property from being calculated until your code uses it for the first time. You’ll want to use lazy initialization when a property’s initial value is computationally intensive or when you won’t know the initial value of a property until after you’ve initialized the object.

关键字 lazy 声明这种属性，必须声明为 var 而不是 let（初始化类时lazy属性没有值，用到它时runtime会改变他的值）

在下载用户头像或者大量计算时是一种可能的使用情景，只有在被用到时才被计算

class Circle {
  //pi是存储属性
  //{ }() is the pattern for a closure that is evaluated immediately, and you use it for lazy properties or to add computation to a stored property
  lazy var pi = {
    return ((4.0 * atan(1.0 / 5.0)) - atan(1.0 / 239.0)) * 4.0
    }()  //"{}()"代表立即执行，但是声明为lazy后不会立即执行，存取它时它才被计算，但是只被计算一次
  var radius: Double = 0
  var circumference: Double {
    return pi * radius * 2
  }
  init (radius: Double) {
    self.radius = radius
  }
}

let circle = Circle(radius: 5) // got a circle, pi has not been run
let circumference = circle.circumference // also, pi now has a value

方法（Methods）

iOS多线程-GCD使用指南

2016-05-13T21:46:00+00:00

最近的计步器App涉及异步API，我开始试图将CMPedometer的查询方法封装为一个函数，这个函数可以返回查询方法得到的结果，方便使用。然而事实却没有这么简单，由于查询方法是异步API，因此只要调用该方法操作就会被分配到另一个线程去做，因此当查询到结果后，调用这个查询方法的方法早已执行完毕，因此返回空，也就是除了查询方法自带的回调block中可以取到查询结果，其他地方没法获取查询结果。

  // stepsInToday永远取不到值
  func queryPedometerTodayTotalData() -> Int {
       var stepsInToday = 0
       self.queryPedometerDataFromDate(NSDate.today()!, toDate: NSDate()) {
           (pedometerData, error) in
           stepsInToday = (pedometerData?.numberOfSteps.integerValue)!
       }
       return stepsInToday
   }

期间试过给 NSOperation 添加依赖，或者使用 dispatch_group_async，但是用这些方法解决异步API 都不奏效，因为异步API操作始终会分去别的线程处理，我开始的解决办法是在返回前阻塞等待一段时间（如2秒），这样就解决了时序问题，但是这种方式并不好，试想如果硬件原因（也可能网络应用相关的延迟）超过这个时间段（2秒），则应用崩溃

  // 通过延时执行的解决方法
  func queryPedometerTodayTotalData() -> Int {
       var stepsInToday = 0
       self.queryPedometerDataFromDate(NSDate.today()!, toDate: NSDate()) {
           (pedometerData, error) in
           stepsInToday = (pedometerData?.numberOfSteps.integerValue)!
       }

       sleep(2) //用于阻塞线程

       return stepsInToday
   }

今天突然看到一篇博文，恍然大悟，解决了困惑已久的问题

//通过信号量机制阻塞线程的解决办法
//注：这个方法会阻塞当前线程，因此应该异步调用，后台让后台线程阻塞无妨
func queryPedometerTodayTotalData() -> Int {
    var stepsInToday = 0
    let semaphore = dispatch_semaphore_create(0)
    self.queryPedometerDataFromDate(NSDate.today()!, toDate: NSDate()) {
        (pedometerData, error) in
        stepsInToday = (pedometerData?.numberOfSteps.integerValue)!
        dispatch_semaphore_signal(semaphore)
    }
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
    return stepsInToday
}

至此对GCD有了进一步认识，结合这篇博文总结一下:

GCD使用指南

后台执行

  let defaultPriority = DISPATCH_QUEUE_PRIORITY_DEFAULT  //该优先级最常用
  let backgroundQueue = dispatch_get_global_queue(defaultPriority, 0) //返回并发队列
  dispatch_async(backgroundQueue, {
    let result = doSomeExpensiveWork()
    dispatch_async(dispatch_get_main_queue(), {
      //使用 `result` 做各种事
    })
  })

可以用 dispatch_queue_create 创建自己的队列，需指定队列名和类型（串行还是并发）
注意，每次调用使用的是 dispatch_async 而不是 dispatch_sync。dispatch_async 将在block执行前立即返回，而 dispatch_sync 则会等到block执行完毕后才返回。内部的调用可以使用 dispatch_sync（因为不在乎什么时候返回），但是外部的调用必须是 dispatch_async（否则主线程会被阻塞）

创建单例

dispatch_once 这个 API 可以用来创建单例。不过这种方式在 Swift 中已不再重要，Swift 有更简单的方法来创建单例。这里只贴OC的实现： ``` swift
- (instancetype) sharedInstance {
  //onceToken:该参数是检查后面第二个参数所代表的代码块是否被调用的谓词 static dispatch_once_t onceToken;
  static id sharedInstance;
  dispatch_once(&onceToken, ^{
  sharedInstance = [[self alloc] init];
  });
  return sharedInstance;
  } ```

摊平 completion block

这个部分解决了我近期碰到的问题
可以使用信号量来阻塞一个线程任意时间，直到一个信号从另一个线程发出。信号量和 GCD 的其他部分一样是线程安全的，并且能够从任意位置被触发

如果想同步执行一个异步API，那可以使用信号量，但是不能修改它

// 在后台队列
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0)
doSomeExpensiveWorkAsynchronously(completionBlock: {
  dispatch_semaphore_signal(semaphore)
})
//下面的方法会阻塞线程，直到 dispatch_semaphore_signal 被调用
//这就意味着 signal 必须从不同的线程被调用，因为当前线程已经被阻塞。永远都不应该在主线程中调用 wait，只能在后台线程中调用它。
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)  //第二个参数是等待超时时间
// 现在开销很大的异步工作已经完成

为什么在已有 completion block 的情况下还要摊平代码？因为方呀，能想到的一种场景是串行执行一组异步程序（即只有前一个任务执行完成，才会继续执行下一个任务）。下面把上述想法简单地抽象成一个 AsyncSerialWorker 类：

//既然已经使用了 DISPATCH_QUEUE_SERIAL，那么队列中 work 的执行顺序不应该是先进先出的吗？
//确实是这样，但如果我们把 work 看成是一个耗时的网络操作，其内部是提交到其他线程并发去执行（dispatch_async），也就是每次执行到 work 就立刻返回了，即使最终结果可能还未返回。
//那么我们想要保证队列中的 work 等到前一个 work 执行返回结果后才执行，就需要 semaphore。例子：
typealias DoneBlock = () -> ()
typealias WorkBlock = (DoneBlock) -> ()

class AsyncSerialWorker {
  private let serialQueue = dispatch_queue_create("com.qiaolibo.serial.queue", DISPATCH_QUEUE_SERIAL)

  func enqueueWork(work: WorkBlock) {
      dispatch_async(serialQueue) {
          let semaphore = dispatch_semaphore_create(0)
          work({
              dispatch_semaphore_signal(semaphore)
          })
          dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
      }
  }
}

let a = AsyncSerialWorker()

for i in 1...5 {
  a.enqueueWork { doneBlock in
      dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
          sleep(arc4random_uniform(4)+1)
          print(i)
          doneBlock()
      }
  }
}
//此时的输出结果为：1，2，3，4，5，如果将关于 semaphore 的代码都注释掉，结果就不会是按顺序输出了。
//dispatch_semaphore_create(0) 当两个线程需要协调处理某个事件时，我们在这里传入 0；内部其实是维护了一个计数器，下面会说到。

限制并发的数量

在上面的例子中，信号量被用作一个简单的标志，但它也可以当成一个有限资源的计数器。如果想针对某些特定的资源限制连接数，可以这样做：

class LimitedWorker {
  private let concurrentQueue = dispatch_queue_create("com.qiaolibo.concurrent.queue", DISPATCH_QUEUE_CONCURRENT)
  private let semaphore: dispatch_semaphore_t

  init(limit: Int) {
    semaphore = dispatch_semaphore_create(limit)
  }

  func enqueueWork(work: () -> ()) {
      dispatch_async(concurrentQueue) {
          dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
          work()
          dispatch_semaphore_signal(semaphore)
      }
  }
}

在创建信号量时，可以限定资源的可用数。这个可用数（long 类型）会在信号量初始化时作为参数传入。每次等待信号量时，dispatch_semaphore_wait 都会消耗一次可用数，如果结果为负，函数会告诉内核阻断你的线程。另一方面，dispatch_semaphore_signal 函数每次执行都会将该可用计数 + 1，以此来表明已经释放了资源。如果此刻有因为等待可用资源而被阻隔的任务，系统会从等待的队列中解锁一个任务来执行。
这个效果类似 NSOperationQueue 的 maxConcurrentOperationCount。如果你使用原生的 GCD 队列而不是 NSOperationQueue，你就能使用信号量来限制并发任务的数量。
每次调用 enqueueWork 都会将 work 提交到一个并发队列，而该并发队列收到任务就会丢出去执行，直到触碰到信号量数量耗尽的天花板（work 入队列的速度太快，dispatch_semaphore_wait 已经消耗完了所有的数量，而之前的 work 还未执行完毕，dispatch_semaphore_signal 不能增加信号量的可用数量）

等待许多并发任务完成

如果你有许多 blocks 任务要去执行，你需要在它们全部完成时得到通知，那可以使用 group。dispatch_group_async 允许你在队列中添加任务（这些任务应该是同步执行的，像计步器的异步查询API放这就无效），而且你会追踪有多少被添加的任务。注意：同一个 dispatch group 能够添加不同队列上的任务，并且能保持对所有组内任务的追踪。当所有被追踪的任务完成时，一个传递给 dispatch_group_notify 的 block 会被触发执行，有点类似于 completion block

dispatch_group_t group = dispatch_group_create()
for item in someArray {
	dispatch_group_async(group, backgroundQueue, {
		performExpensiveWork(item: item)
	})
}
dispatch_group_notify(group, dispatch_get_main_queue(), {
	// 所有任务都已完成
}

深入细节：

// 必须在后台队列使用
dispatch_group_t group = dispatch_group_create()
  for item in someArray {
    dispatch_group_enter(group)
    performExpensiveAsyncWork(item: item, completionBlock: {
      dispatch_group_leave(group)
  })
}

dispatch_group_wait(group, DISPATCH_TIME_FOREVER)

// 所有任务都已完成

和信号量一样，groups 同样保持着一个线程安全的、可以操控的内部计数器。你可以使用这个计数器来确保在 completion block 执行前，多个大开销任务都已执行完毕。使用 enter 来增加计数器，使用 leave 来减少计数器。dispatch_group_async 已为你处理了这些细节，所以尽情地享受即可
代码片段的最后一行是 wait 调用：它会阻断当前线程并且等计数器到 0 时继续执行。注意，虽然你使用了 enter/leave API，但你还是能够通过 dispatch_group_notify 将 block 提交到队列中。反过来也成立：如果你用了 dispatch_group_async API，也能使用 dispatch_group_wait。
dispatch_group_wait 和 dispatch_semaphore_wait 一样接收一个超时参数。再次重申，我更喜欢 DISPATCH_TIME_FOREVER。另外，不要在主线程中调用 dispatch_group_wait
上面两段代码最大的区别是，notify 可以在主线程中调用，而 wait 只能在后台线程中调用（至少 wait 部分要在后台线程中调用，因为它会完全阻塞当前线程）

隔离队列

Swift 中的字典（和数组）都是值类型，当它们被修改时，它们的引用会被一个新的副本所替代。但是，因为更新 Swift 对象的实例变量操作并不是原子性的，所以这些操作不是线程安全的。如果两个线程同一时间更新一个字典（比如都添加一个值），而且这两个操作都尝试写同一块内存，这就会导致内存崩坏。我们可以使用隔离队列来实现线程安全

//先构建一个标识映射 Identity Map，一个标识映射是一个字典，表示从 ID 到 model 对象的映射
//标识映射（Identity Map）模式将所有已加载对象放在一个映射中，确保所有对象只被加载一次，并且在引用这些对象时使用该映射来查找对象。
//在处理数据并发访问时，需要一种策略让多个用户共同操作同一个业务实体，这个很重要。
//同样重要的是，单个用户在一个长运行事务或复杂事务中始终使用业务实体的一致版本。
//标识映射模式会为事务中使用所有的业务对象保存一个版本，如果一个实体被请求两次，会得到同一个实体。
class IdentityMap<T: Identifiable> {
	var dictionary = Dictionary<String, T>()

	func object(forID ID: String) -> T? {
		return dictionary[ID] as T?
	}

	func addObject(object: T) {
		dictionary[object.ID] = object
	}
}
//这个对象基本就是一个字典封装器，如果有多个线程在同一时刻调用函数 addObject，内存将会崩坏，因为线程会操作相同的引用。
//这也是操作系统中的经典的"读者-写者问题，简而言之，我们可以在同一时刻有多个读者，但同一时刻只能有一个线程可以写入。

GCD 针对在该场景提供如下四个 API：
- dispatch_sync
- dispatch_async
- dispatch_barrier_sync
- dispatch_barrier_async

理想的情况是，读操作并发执行，写操作异步执行并且必须确保没有其他操作同时执行。GCD 的 barrier 集合 API 提供了解决方案：它们会在队列中的任务清空后执行 block。使用 barrier API 可以限制我们对字典对象的写入，并且确保我们不会在同一时刻执行多个写操作，或者在执行写操作同时执行读操作

class IdentityMap<T: Identifiable> {
  var dictionary = Dictionary<String, T>()
  let accessQueue = dispatch_queue_create("com.qiaolibo.isolation.queue", DISPATCH_QUEUE_CONCURRENT)

  func object(withID ID: String) -> T? {
    var result: T? = nil
    dispatch_sync(accessQueue, {
      result = dictionary[ID] as T?
    })
    return result
  }

  func addObject(object: T) {
    dispatch_barrier_async(accessQueue, {
      dictionary[object.ID] = object
    })
  }
}

如上：

dispatch_sync 将会分发 block 到我们的隔离队列上，然后等待其执行完毕。通过这种方式，我们就实现了同步读操作（如果我们想异步读取，getter 方法就需要一个 completion block）。因为 accessQueue 是并发队列，这些同步读取操作可以并发执行，也就是允许同时读
dispatch_barrier_async 将分发 block 到隔离队列上，async 异步部分意味着会立即返回，并不会等待 block 执行完毕。这对性能有好处，但是在一个写操作后立即执行一个读操作会导致读到一个半成品的数据（因为可能写操作还未完成就开始读了）
dispatch_barrier_async 中 barrier 部分的逻辑是：barrier block 进入队列后不会立即执行，而是会等待该队列其他 block 执行完毕后再执行。这就保证了我们的 barrier block 每次都只有它自己在执行。而所有在它之后提交的 block 也会一直等待这个 barrier block 执行完再执行
传入 dispatch_barrier_async() 函数的 queue，必须是 dispatch_queue_create 创建的并发 queue。如果是串行 queue 或者是 global concurrent queues，这个函数就变成 dispatch_async() 了

总结

GCD 是一个具备底层特性的框架，通过它，我们可以构建高层级的抽象行为。这篇文章较为全面的讲述了 GCD 的相关应用领域，对iOS多线程有了更进一步的认识，其中很多内容还只停留在概念层面，待以后实际运用到再深入理解。

Swift基础语法（四）

2016-05-09T16:11:00+00:00

本篇作为Swift的第四篇，主要介绍了Swift中的枚举类型，它和其它语言相比有其特殊性

枚举（enumeration）

枚举作为一种普通类型（common type），定义了一组相关的数据
不同于其他语言，Swift 中的枚举中可以拥有方法，属性和协议声明
可以用枚举处理响应，存储状态或者包装数据（encapsulate values）

An enumeration can have methods, computed properties and protocol declarations, all while acting as a nice state machine.

用关键字 enum 声明一个枚举

enum Month {
  case January
  case February
  case March
  case April
  case May
  case June
  case July
  case August
  case September
  case October
  case November
  case December
}

//简化版
enum Month {
  case January, February, March, April, May, June, July, August, September, October, November, December
}

使用 . 存取枚举中的内容，利用Swift的类型推导可以省去枚举名

func schoolSemester(month: Month) -> String {
  switch month {
  case .August, .September, .October, .November, .December:
    return "Autumn"
  case .January, .February, .March, .April, .May:
    return "Spring"
  default:
    return "Not in the school year"
  }
}

原始值（Raw values）

和 C 不同，Swift 不会给枚举指定默认的整型值，但是可以在枚举名后面指定原始值的类型，该类型可以是String, Float或 Character，更为灵活，被赋予的raw value也可以是无序的

//如果省略了第一个之后的默认原始值，则编译器会自增赋值
enum Month: Int {
  case January = 1, February = 2, March = 3, April = 4, May = 5, June = 6, July = 7, August = 8, September = 9, October = 10, November = 11, December = 12
}

用枚举实例的 rawValue 属性来存取原始值（raw value）

func monthsUntilWinterBreak(month: Month) -> Int {
  return Month.December.rawValue - month.rawValue
}
monthsUntilWinterBreak(.April) // 8

用raw value初始化枚举

//Enumeration initializers with the rawValue: parameter are failable initializers, meaning if things go wrong, the initializer will return nil.
//这里初始化函数不能保证你赋予的原始值在枚举类型中存在，因此返回一个Optional
let fifthMonth = Month(rawValue: 5)
monthsUntilWinterBreak(fifthMonth) // Error: value not unwrapped
//安全的做法
if let fifthMonth = Month(rawValue: 5) {
  monthsUntilWinterBreak(fifthMonth)  // 7
}

关联值（Associated values）

和原始值（raw value）相似，但是有几点不同
- 每一个枚举case可以包含0个或多个关联值
- 每一个case的关联值都有他们自己的类型
- 定义一个关联值和定义一个方法的参数名相似

一个枚举可以指定原始值或关联值，但是不能同时指定

//银行取款的例子，有余额则做计算，余额不足则显示错误信息，这两种操作的结果是不同类型的
var balance = 100

enum WithdrawalResult {
  case Success(Int)
  case Error(String)
}

func withdraw(amount: Int) -> WithdrawalResult {
   if amount <= balance {
     balance -= amount
     return .Success(balance)
   } else {
     return .Error("Not enough money!")
   }
}

let result = withdraw(99)
switch result {
  case let .Success(newBalance):
    print("Your new balance is: \(newBalance)")
  case let .Error(message):
    print(message)
}

//存取枚举的关联值在现实生活中的例子很多
//服务器通常用枚举区分不同类型的请求
enum HTTPMethod {
  case GET
  case POST(String)
}

枚举作为状态机（Enumeration as state machine）

生活中的红绿灯就可以看作一个状态机，同一时刻它只能处在一个状态（前阵子面试被问到状态机我还不知所云。。。囧）

枚举类型就可以保证同一时刻只处在同一状态

enum TrafficLight {
  case Red, Yellow, Green
}
let trafficLight = TrafficLight.Red

可选类型（Optionals）

Optional的底层实现就是一个枚举类型

可以不通过 ? 声明一个Optional

let email: Optional<String> = .None
let website: Optional<String> = .Some("devqiao.net") //associated value

switch website {
  case .None:
    print("No value")
  case let .Some(value):
    print("Got a value: \(value)")
}

Swift hides the implementation details with things like if-let binding, the ? and ! operators, and keywords such as nil.
// nil和.None在底层是相同的值
let optionalNil: Optional<Int> = .None
optionalNil == nil    // true
optionalNil == .None  // true

Swift基础语法（三）

2016-05-02T21:26:25+00:00

本篇作为Swift的第三篇，主要简述Swift中的结构体和类

结构体（Structures）

值类型（value types），直接存取，拷贝赋值，用关键字 struct 声明，建立在内存栈区（stack）
许多Swift内建类型都是结构体，如 Int Array Float Double Bool Dictionary Set String 这是Swift设计的独特之处
用 . （dot syntax）存取结构体成员
要修改结构体里声明为 var 的成员，则该结构体也必须声明为 var
用 init 自定义结构体的初始化函数，如果自定义了，则原来的默认初始化函数将失效，除非自己再定义一遍
自定义初始化函数式，所有属性（stored properties）都必须赋初值，Swift不会赋默认初值（定义为let的Optional除外，Optional默认nil）
结构体中可以包含方法（method），用 .调用结构体中的方法
用关键字 extension 定义一个拓展，可以拓展结构体/类/枚举的属性和方法。它也允许拓展内建类型

结构体比类更快更安全（value semantics and copying）

语法

//结构体声明
struct 结构体名 {
  var a: Double = 100.0  //可以指定默认值
  let b: 可以为结构体类型
}
//结构体实例化
let c = 结构体名(a: 值, b:值)  //Swift会自动生成这类初始化函数
//存取结构体成员
结构体名.a
结构体名.b.子成员

类（Classes）

引用类型（reference types），类保存了一个内存指针，建立在内存堆区（heap）
通常用结构体代表值，用类代表对象
用关键字 class 声明
和结构体不同，类不自动提供初始化函数，你必须自己定义，定义方法和结构体一致
鉴定对象：===，检查两个引用类型是否指向同一块内存区
类具有可变性（mutability），改变它则在它自身上做改变结构体一般意味着不可变性（immutability），改变它则意味着得到一个新值
存取控制（写在变量前）：
- public：模块内和导入的模块均可用
- internal：模块内可用，导入的模块不可用，默认值
- private：定义所在的本文件内可用，文件级（file level，意味着把不同类定义在同一个文件一样可以存取其他类的private属性）

Struct or Class ？

Struct

隐含值的拷贝
数据语义上不可变
在代表值的时候使用，意味着值（value）的改变
高效内存分配（stack）
Class
隐含共享对象
数据语义上可变
代表事物的时候使用，意味着状态（state）的改变，有副作用（side effect）
较慢的内存分配（heap）

类进阶

继承（inheritance）

Swift是单继承（single inheritance），即只能有一个父类
继承的深度没有限制
用关键字 override 声明重载函数
关键字 super 代指父类，重载时最好先用 super
用关键字 final 声明的类将不允许被继承（Preventing inheritance）
用关键字 final 声明的方法将不允许被重载
子类的初始化方法在初始化本类属性后，调用父类的初始化函数（two-phase initialization）
指定初始化和便捷初始化
- 关键字 required 标记的初始化函数在子类中必须重载，说明这个初始化函数重要到所有继承链的类都要实现
- 关键字 convenience 标记的初始化函数必须调用同类的其他初始化函数，它最终必须调用指定初始化函数，当需要调用其他初始化函数实现便捷初始化方法时用
类的声明周期（lifecycle）：不同于栈上内容出了作用于（scope）的自动释放，在堆上的类不会自动释放
- 引用计数（reference counting）/ ARC（automatic reference counting）
关键字 deinit 声明析构函数，和 init 不同，deinit 不是必须的，在对象被清出内存前被调用（Swift在引用计数为0时自动调用，按继承链逐一析构）
引用计数造成的负作用–循环引用（retain cycle）导致的内存泄露（memory leak）：用 weak 声明引起循环引用的属性/变量，默认是 strong

CoreMotion框架-CMPedometer

2016-04-28T09:27:00+00:00

比赛作品涉及计步功能，计步属于健康范畴，当前Apple的HealthKit可以很好的提供健康数据，但是由于涉及隐私，在添加HealthKit时必须要付费的开发者账号，而且包含HealthKit的App审核也更严格。我目前只需实现简单的计步功能，因此关注到了CoreMotion框架的CMPedometer类，今天简单说说：

CMPedometer

这块国内资料较少，科学上网一阵之后发现官方文档已经足够清晰明了。顾名思义，该类为了方便获取行走相关数据而设计，除了可用性检查几个关键方法：

生成计步器实时数据

//Swift
func startPedometerUpdatesFromDate(_ start: NSDate,
                       withHandler handler: CMPedometerHandler)

start：NSDate类型，指明开始获取数据的时间，不能为空
handler：传入一个block，每当新数据可用时，这个block在后台线程（异步后台串行队列）重复执行，不能为空
App暂停时，计步数据暂停生成，返回前台或后台执行时，计步数据继续生成
可用stopPedometerUpdates停止更新

获取历史计步数据

//Swift
func queryPedometerDataFromDate(_ start: NSDate,
                             toDate end: NSDate,
                    withHandler handler: CMPedometerHandler)

start：NSDate类型，指明开始获取数据的时间，不能为空
end：NSDate类型，指明结束获取数据的时间，不能为空
handler：传入一个block，这个block在后台线程（异步后台串行队列，和实时更新方法在同一队列）执行一次，不能为空
最多只能获取过去7天的计步数据，如果start参数设置比7天前还早，就只返回可用数据，所以要是做长期分析可能会用到后台服务器

CMPedometerHandler

上面提到的block

//Swift
typealias CMPedometerHandler = (CMPedometerData?, NSError?) -> Void

步数主要在CMPedometerData类的numberOfSteps属性里取

坑

昨天做了个测试，踩进坑里倒腾了一下午，总结一下：

CMPedometer最好声明为一个属性！我开始放在viewDidLoad中，声明的临时变量，结果始终取不到数据，报错Error Domain=CMErrorDomain Code=103 "(null)"。原因就是该方法在启动执行完毕后，临时变量就释放了。对于这样一个持续获取数据的类来说，自然在启动后获取不到数据，这里利用打印block中的error参数可以帮助找到问题
实时更新计步数据的方法异步运行在后台串行队列里，因此如果需要实现界面也跟着实时变化，需要异步回主线程更新UI（GCD很便捷），不然只有在停止数据更新时界面才会变

最后，stackoverflow要多用！

Swift基础语法（二）

2016-04-22T16:33:25+00:00

本篇作为Swift的第二篇，主要简述Swift中的集合类型

集合类型（Collection Types）

数组（Arrays）

有序，元素类型相同，零序（zero-indexed），存储在内存的一段连续存储区
一种类型，传值时拷贝
空数组：[]
声明一个不可变数组：
- let numbers: Array<Int>
- let inferredNumbers = Array<Int>() //类型推导
- let alsoInferredNumbers = [Int]() //简写，常用
数组赋初值
- let evenNumber = [2, 4, 6, 8] //类型推到
- let allZero = [Int](count: 5, repeatedValue: 0) //[0, 0, 0, 0, 0]
数组元素的存取
- 索引：element[0]
- 使用range：let numbers = numberArray[1...2]
数组的操作
- isEmpty count
- first
  last
  minElement()
  maxElement()
- contains(元素)
- append(元素)
  insert(元素)
  removeLast()
  removeAtIndex(索引)
- 更新：利用索引直接重置对应值，如果用range，超出的部分视为添加元素
- sort()：返回排序后的数组的拷贝 sortInPlace()：就地返回排序后的数组
- for-in 遍历数组元素
- 序列操作（sequence operations）
  reduce(_:combine:)
  filter(_:)：按条件过滤元素到新数组
  map(_:)：对每个元素作指定操作然后映射到新数组

字典（Dictionaries）

无序键值对，一个字典中的键是唯一的，值可以重复出现，所有的键类型相同，所有的值类型相同，hash实现
声明一个不可变字典：
- let pairs: Dictionary<String, Int>
- let inferredPairs = Dictionary<Sting, Int>() //类型推导
- let alsoInferredNumbers = [String: Int]() //简写，常用
字典赋初值：let dict = ["A": 1, "B": 2, "C": 3]
空字典：[:]
字典元素的存取：
- 索引：dict["A"] //Optional(1)，不同与数组，如果没有对应键，则返回nil，不会运行时崩溃
字典的操作
- isEmpty count
- 键数组或值数组：Array(dict.keys) Array(dict.values)
- 添加、修改：
  - dict.updateValue(值, forKey: 键)
  - dict[键] = 值 //简写
- 删除：
  - dict.removeValueForKey(键)`
  - dict[键] = nil //简写
- 遍历（使用元组）：for (key, value) in dict
- 序列操作参考数组

集合（Sets）

无序，唯一性，所有元素类型相同，hash实现

hashing：the process of transforming a value - String, Int, Double, Bool, etc - to a numeric value, known as the hash value.
声明集合：
- let set: Set<Int>
- let set = Set<Int>() //类型推导
- 空集合：[]
- 集合赋初值（与数组共享）：
  - let set: Set<Int> = [1, 2, 3, 1] //不声明类型就会认为是数组，这里1会被视为一个（唯一性）
  - let set: Set<Int> = [1, 2, 3, 1] //类型推导
- 集合的操作：
  - isEmpty count
  - contains(值)
  - first last 不知道返回哪一个（无序性），但是在集合只有0个或1个元素的时候会比较便捷
  - 添加：insert(值)
  - 删除：remove(值)
  - 遍历：for-in
  - 集合操作（set operations）：
    - Union：union(_:) 创建一个新集合，该集合包含两个集合的并集
    - Intersect：intersect(_:) 创建一个新集合，该集合包含两个集合的交集
    - Subtract： subtract(_:) 创建一个新集合，该集合包含两个集合的补集
    - Exclusive Or：subtract(_:) 创建一个新集合，该集合包含两个集合的并集减去交集

Swift基础语法（一）

2016-04-22T16:33:25+00:00

本篇作为Swift的第一篇，主要简述Swift中的基础数据类型

变量和常量（Constants&Variables）

Swift中用let声明常量，常量在初次赋值后不能再被改变
Swift中用var声明常量，常量在初次赋值后可以被更改
语法
```
let pi: Double = 3.14159
var variableNumber: Int = 1_000__000
```
注：Swift中可以用下划线_分隔大数字，增加人类可读性，数量和位置随意。 下划线 _ 还有占位符的作用，代表忽略该项，后面会用到

类型转换（Type conversion）

将待转量用小括号括起来再在前面加上想要转成的类型即可：如 Int(doubleNumber)
Swift类型要求非常严格，将一个类型的值赋给另一个类型的变量时编译器会报错
同样，在两种不同类型的操作数做算数操作时，必须手动强制转换为同一类型变量，否则报错。这和C++的向高精度自动转换有区别
语法
```
var integer: Int = 100
var decimal: Double = 12.5
var sum = integer + Int(decimal)
```

元组（Tuples）

多个成组或多个相关的元素可以声明为元组

用.访问元组中的元素，如果没有指定索引值，则默认为从0开始的数字索引

语法

//默认索引值的元组，从0开始
let coordinates: (Double, Int) = (2.1, 3)
let x: Int = coordinates.0
let y: Int = coordinates.1

//定义索引值的元组
let coordinates3D: (x: Int, y: Int, z: Int) = (2, 3, 1)
let x: Int = coordinates3D.x
let y: Int = coordinates3D.y
let z: Int = coordinates3D.z
let (x, y, z) = coordinates3D  //同上三句

类型推导（Type inference）

Swift具有类型推导特性，在声明变量时可以省略类型声明，系统会自动判断变量的类型
在Xcode中按住option单击或三指点击未声明类型的变量可以查看系统推导的类型
语法
```
let typeInferredInt = 10
```

操作符（Operations）

Swift的算数操作符和其他语言相似：+ - * / % << >> += -=……
比较操作符：== != > < >= <=……
布尔类型（Bool）及逻辑操作符：&& || !

用小括号()设定操作优先级

语法

let add = 2 + 6
let subtract = 10 - 2
let multiply = 2 * 4
let divide = 24 / 3
let modulo = 11.6 % 1.2  //0.8  Swift可以对小数求余
let shiftLeft = 1 << 3   //位移操作将十进制数的二进制形式位移后再返回十进制结果

字符串（Strings）

Character类型存储单一字符，String类型用来存储一串字符
字面量（string literal）：用双引号括起来的字符
串接（Concatenation）：+ += 可以用来连接多个字符串
插入（Interpolation）：在字面量双引号中用\(插入内容)插入内容

== 符可以用作字符串判等，> < 用作字符串比较时依据字母表序位置先后判断结果

语法

let message: String = "Hello"
let exclamationMark: Character = "!"
let sentence = message + String(exclamationMark)  //"Hello!"

let name = "Qiao"
let sayHi = "Hello my name is \(name)!"

let guess = "dog"
let dogEqualsCat = guess == "cat"  //false
let order = "cat" < "dog"          //true

控制语句（Control flow）

if if - else if - else if - else
三元控制符：(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>
switch <CONDITION> case: case: default:

模式匹配（pattern matching）：let-where 语法

语法

let number = 10
switch (number) {
  case let x where x % 2 == 0:
      print("Even")
  default:
      print("Odd")
 }

//部分匹配（partial matching）
let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (0, 0, 0): // 1
      print("Origin")
  case (_, 0, 0): // 2
      print("On the x-axis.")
  case (0, _, 0): // 3
      print("On the y-axis.")
  case (0, 0, _): // 4
      print("On the z-axis.")
  default:        // 5
      print("Somewhere in space")
 }

//保留对应值的部分匹配
let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (0, 0, 0):
      print("Origin")
  case (let x, 0, 0):
      print("On the x-axis at x = \(x)")
  case (0, let y, 0):
      print("On the y-axis at y = \(y)")
  case (0, 0, let z):
      print("On the z-axis at z = \(z)")
  case (let x, let y, let z):
      print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
 }

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)
switch (coordinates) {
  case (let x, let y, _) where y == x:
      print("Along the y = x line.")
  case (let x, let y, _) where y == x * x:
      print("Along the y = x^2 line.")
  default:
  break
 }

范围（Ranges）

闭区间（closed range）： ...

开区间（half-open range）： ..<

语法

let closedRange   = 0...5  //范围从0到5，包括5
let halfOpenRange = 0..<5  //范围从0到4，不包括5

循环（Loops）

for-in
while
repeat-while：类似于其他语言的do-while
用 break 退出循环， continue 继续下一次循环

标签语句（Labeled statements）：和 continue 配合使用，可以使程序跳到指定语句，类似C中的 goto

语法

//for循环
for <VARIABLE> in <RANGE> {
    <LOOP CODE>
}

//while循环
while <CONDITION> {
    <LOOP CODE>
}

//repeat-while循环
repeat {
    <LOOP CODE>
} while <CONDITION>

//标签语句
var sum = 0

rowLoop: for row in 0..<8 {
    columnLoop: for column in 0..<8 {
        if row == column {
            continue rowLoop
        }
        sum += row*column
    }
}

函数（Functions）

用 func 关键字声明函数
可以在第二个或后续参数标签前指明一个外部标签，在调用时可以使代码更为简洁
返回值用 -> 接在函数声明后面，可以返回元组
Swift的参数传递是值传递（pass-by-value），在传入参数前做一次拷贝，函数体内可以看成是let，内部改变不会影响外部，如果要用引用传参（pass-by-reference）需要在参数前加 inout 关键字，声明为引用传参的函数在调用时参数前要加 &,以指明这是引用方式

函数可以作为变量传递声明时类似于 var function: (Int, Int) -> Int

语法

func 函数名(第一个参数标签: 参数类型, 指定的参数外部标签 参数标签: 参数类型 = 参数默认值) -> 函数返回值  {
    函数体
    return 返回值
}

闭包（Closures）

可以理解为匿名函数

闭包可以“捕获”作用域内的变量，任何对其改变都会在闭包内外收到影响

语法

//闭包声明
var multiplyClosure: (Int, Int) -> Int  //和函数类型的变量基本一致
//闭包赋值
multiplyClosure = { (a: Int, b: Int) -> Int in
    return a * b
}
//闭包使用
let result = multiplyClosure(4, 2)      //result=8

//闭包简化语法
//如果只有一句表达式，可以省略return
//利用类型推倒机制，在已经声明过的前提下可以省略返回类型和参数类型
//参数列表：参数可以用从0开始的序列引用
multiplyClosure = {
    $0 * $1
}

//尾闭包语法（trailing closure syntax）
//当一个闭包作为函数的最后一个参数时, 尾闭包可以化简代码
//原来
operateOnNumber(4, 2, operation: {
    $0 + $1
})
//尾闭包
operateOnNumber(4, 2) {
    $0 + $1
})

可选类型（Optional）

Nil代表空（absence of value）
很多语言用哨兵值（Sentinel values）代表空值，例如0代表没有，但是容易引起歧义，对于这个0 不同人有不同理解，因此Swift引入和Optionals类型
Optional可以被类比为一个盒子，它可以包含一个值，也可以为空，用 ? 声明：var errorCode: Int?
Optional强制拆包（force unwrapping）：用 ! 跟在可选类型变量后。一般不推荐这种做法，强制拆包会，如果值为空，可能会引起运行时crash
if let binding：这种方式较为安全的存取Optional

nil coalescing：当拆包一个Optional为nil时，用 ?? 指定默认值

语法

//一次拆包多个值
let authorName: String? = "Qiao"
let authorAge: Int? = 30
if let name: String = authorName,
        age: Int = authorAge {
          print("The author is \(name) who is \(age) years old.")
     } else {
          print("No author or no age.")
}

//nil coalescing
var result: Int = optionalInt ?? 0