Swift笔记-让你2小时学会Swift

概述过年不能闲着，一边学习Swift，一边写笔记，相信在有一定其他语言基础的情况下用1.5小时看完该文章即可掌握。然后再花30分钟打开XCode写个Demo. 生命中拿出2小时来认识一门语言，很值吧！ 笔记共分为两部分，一Swift基础知识，二使用Xcode开发一个软件 [TOC] swift基础知识 变量和常量 //定义变量var myVariable = 123//定义常量let myCo

过年不能闲着，一边学习Swift，一边写笔记，相信在有一定其他语言基础的情况下用1.5小时看完该文章即可掌握。然后再花30分钟打开XCode写个Demo.
生命中拿出2小时来认识一门语言，很值吧！
笔记共分为两部分，一Swift基础知识，二使用Xcode开发一个软件
[TOC]

swift基础知识 变量和常量

//定义变量var myVariable = 123//定义常量let myConstan@R_301_6672@iable = 123// 隐式指定整数类型var anInteger = 2// 明确指定整数类型let anExplicitInteger :Int = 2

元组

let aTuple = (1,"Yes")let anotherTuple = (aNumber: 1,aString: "Yes")let theOtherNumber = anotherTuple.aNumber  // = 1

其他用法

let http404Error = (404,"Not Found")let (statusCode,statusMessage) = http404Errorprint("The status code is \(statusCode)")

更多用户函数返回值，返回两个以上的值，跟golang很像

数组

var arrayOfIntegers : [Int] = [1,2,3]// 隐式指定var implicitArrayOfIntegers = [1,3]// 也可以创建空数组,但必须提供其类型let anotherArray = [Int]()//使用 append 函数向数组的末尾追加对象myArray.append(4)//数组中的任意位置插入对象myArray.insert(5,atIndex: 0)

字典

字典是一种将键映射到值的类型，类似Java的Map,PHP的数组

var crew = [          "Caption": "Jean-Luc Picard","First officer": "William Riker","Second Officer": "Data"];crew["Captain"]// = "Jean-Luc Picard"

控制流 if

if 1+1 == 2 {         println("The math checks out")}

@H_419_53@for-in

let looPingArray = [1,3,4,5]var loopSum = 0for number in looPingArray {     loopSum += number}loopSum // = 15

var firstCounter = 0     for index in 1 ..< 10 {         firstCounter++     }// 循环9次var secondCounter = 0for index in 1 ... 10 { // 注意是三个句点,不是两个         secondCounter++     }// 循环10次var sum = 0for var i = 0; i < 3; i++ {    sum += 1 }sum // = 3

while

var countDown = 5while countDown > 0 {     countDown--}countDown // = 0

var countUP = 0do {         countUp++} while countUp < 5countUp // = 5

if-let

可以用 if-let 语句检查一个可选变量是否包 含值。如果包含,则将这个值指定给一个常量变量,然后运行某段代码。这样可以减少很 多行代码,同时又能够保证安全性

var conditionalString : String? = "a string"     if let theString = conditionalString? {         println("The string is '\(theString)'")     } else {         println("The string is nil")}// 输出 "The string is 'a string'"

函数 单返回值简单函数

两个参数一个返回值，都为Int

func thirdFunction(firstValue: Int,secondValue: Int) -> Int {         return firstValue + secondValue     }thirdFunction(1,2)

使用元组多返回值

func fourthFunction(firstValue: Int,secondValue: Int)         -> (doubled: Int,quadrupled: Int) {         return (firstValue * 2,secondValue * 4)     }fourthFunction(2,4)// 用数字访问:fourthFunction(2,4).1 // = 16// 其他相同,只是使用了名字:fourthFunction(2,4).quadrupled // = 16

外部名称调用

在定义函数时,可以为参数指定名字。当无法马上明白每个参数的用途时,这一功能会非 常有用。可以像下面这样来定义参数名字:

func addNumbers(firstNumber num1 : Int,toSecondNumber num2: Int) -> Int {         return num1 + num2}addNumbers(firstNumber: 2,toSecondNumber: 3)  // = 5

在为参数创建名字时,就是为参数创建一个内部名字和一个外部名字,一个参数的内部名字应当与外部名字相同。将同一个名字输 入两次也没有什么问题,但的确有一种简便的方式来定义一个外部名字与内部名字相同的 参数——就是在参数名之前放一个 # 符号

func multiplyNumbers(#firstNumber: Int,#multiplIEr: Int) -> Int {         return firstNumber * multiplIEr}multiplyNumbers(firstNumber: 2,multiplIEr: 3)  // = 6

将函数用作变量

var numbersFunc: (Int,Int) -> Int;// numbersFunc现在可以存储任何接受两个Int并返回一个Int的函数numbersFunc = addNumbersnumbersFunc(2,3) // = 5

闭包closure

sort需要传递一个闭包作为参数

var numbers = [2,34,6,33,1,67,20]var numbeRSSorted = numbers.sort( { (first,second ) -> Bool in        return first < second})

闭包只包含一行代码,可以省略 return 关键字

var numbeRSSorted = numbers.sort( {  > 
var numbeRSSorted = numbers.sort(){  > 
var comparator = {(a: Int,b: Int) in a < b}comparator(1,2)  // = true
}print(numbeRSSorted)
})print(numbeRSSorted)

如果一个闭包是函数调用中的最后一个参数,可以将它放在括号外面。这纯粹是为 了提高可读性,不会改变闭包的工作方式

闭包放在变量里面

class Vehicle {    var color: String?    var maxSpeed = 80    func description() -> String {        return "A \(self.color) vehicle"    }    func travel() {        print("Traveling at \(maxSpeed) kph")    }}

对象 定义

var redVehicle = Vehicle()redVehicle.color = "Red"redVehicle.maxSpeed = 90redVehicle.travel() // 输出"Traveling at 90 kph" redVehicle.description() // = "A Red vehicle"

使用

class Car: Vehicle {// 继承类可以重写函数             overrIDe func description() -> String {                 var description = super.description()                 return description + ",which is a car"} }

overrIDe func description() -> String {         var description = super.description()         return description + ",which is a car"}

继承

要重写一个函数,要在子类中重新声明它,并添加 overrIDe 关键字

在一个被重写的函数中,可以通过 super 回调该函数在父类中的版本

class InitAndDeinitExample {    // 指定的初始化器(也就是主初始化器)    init() {        print("I've been created!")    }    // 便捷初始化器,是调用上述指定初始化器所必需的    convenIEnce init (text: String) {        self.init() // 这是必需的        print("I was called with the convenIEnce initializer!")    }    // 反初始化器    deinit {        print("I'm going away!")    }}var example : InitAndDeinitExample?// 使用指定的初始化器example = InitAndDeinitExample() // 输出"I've been created!"example = nil // 输出"I'm going away"// 使用便捷初始化器example = InitAndDeinitExample(text: "Hello")// 输出"I've been created!"// 然后输出"I was called with the convenIEnce initializer"

convenIEnce init? (value: Int) {    self.init()    if value > 5 {        // 不能初始化这个对象;返回nil,表示初始化失败 return nil    } }

初始化与反初始化

let failableExample = InitAndDeinitExample(value: 6)// = nil

创建一个可以返回 nil 的初始化器(也称为可以失败的初始化器),就在 init 关键字的后面放上一个问号,并在初始化器确定它不能成功地构造该对象时,使用 return nil:

在使用一个可以失败的初始化器时,任何可以在其中存储该结果的变量都是可选的:

protocol Blinking{    var isBlinking:Bool{get}    var blinkSpeed: Double { get set }    func startBlinking(blinkSpeed: Double) -> VoID    }class light:Blinking{    var isBlinking = false    var blinkSpeed = 1.2    func startBlinking(blinkSpeed: Double) {            print("Now my speed is \(self.blinkSpeed)")    }    }

协议

使用协议的好处是,可以利用 Swift 的类型体系来引用任何遵守某一给定协议的对象，个人现在理解为是Interface概念。

extension Int {         var doubled : Int {             return self * 2         }         func multiplyWith(anotherNumber: Int) -> Int {             return self * anotherNumber} }2.doubled  // = 44.multiplyWith(32) // = 128

extension Int : Blinking {    var isBlinking : Bool {        return false;    }    var blinkSpeed : Double {        get {            return 0.0; }        set {            // 不做任何事情        } }    func startBlinking(blinkSpeed : Double) {        print("I am the integer \(self). I do not blink.")    } }2.isBlinking // = false2.startBlinking(2.0) // 输出"I am the integer 2. I do not blink."

扩展

还可以利用扩展使一个类型遵守一个协议

// 可供所有人访问public var publicProperty = 123//如果将一个方法或属性声明为 private,那只能在声明它的源文件内部看到它:// 只能在这个源文件中访问private var privateProperty = 123// 仅能供本模块访问// 这里的'internal'是默认的,可以省略 internal var internalProperty = 123

访问控制

在将一个方法或属性声明为 public 时,App 中的所有人都能看到它:

class Vector2D {    var x : float = 0.0    var y : float = 0.0    init (x : float,y: float) {        self.x = x        self.y = y    }   }func +(left : Vector2D,right: Vector2D) -> Vector2D {    let result = Vector2D(x: left.x + right.x,y: left.y + right.y)    return result}let first = Vector2D(x: 2,y: 2)let second = Vector2D(x: 4,y: 1)let result = first + second

运算符重载

类似C++的运算符重载

class Tree <T> {    // 'T'现在可以用作一种类型 var value : T    var value:T    var children : [Tree <T>] = []    init(value : T) {        self.value = value    }    func addChild(value : T) -> Tree <T> {        var newChild = Tree<T>(value: value)        children.append(newChild)        reutrn newChild    }}// 整数树let integerTree = Tree<Int>(value: 5)// 可以增加包含Int的子树 integerTree.addChild(10)//用Swift设计程序 | 45integerTree.addChild(5)// 字符串树let stringTree = Tree<String>(value: "Hello")stringTree.addChild("Yes")stringTree.addChild("Internets")

泛型

Swift与Java泛型相同

let string1 : String = "Hello"     let string2 : String = "Hel" + "lo"     if string1 == string2 {         println("The strings are equal")  }

if string1.hasPrefix("H") {         println("String begins with an H")     }     if string1.hasSuffix("llo") {         println("String ends in 'llo'")     }

字符串

比较字符串

查找字符串

let stringToConvert = "Hello,Swift"let data = stringToConvert.dataUsingEnCoding(NSUTF8StringEnCoding)

数据 Swift with cocoa用Xcode开发软件

打开Xcode 7.2

STEP1

打开Xcode新建Project选择OSX Application


STEP2



import Cocoaclass VIEwController: NSVIEwController {    @IBOutlet weak var timestamp:NSTextFIEld!    @IBOutlet weak var dateLabel:NSTextFIEld!    @IBAction func calc(sender:NSbutton){                //将输入的字符串转为Nsstring        let string = Nsstring(string: self.timestamp.stringValue)                //转为double类型        let ts:NSTimeInterval = string.doubleValue                //转换日期        let date = NSDate(timeIntervalSince1970: ts)                //日期格式化        let dfmatter = NSDateFormatter()        dfmatter.dateFormat="yyyy年MM月dd日"                //显示到Label        dateLabel.stringValue = dfmatter.stringFromDate(date)    }    overrIDe func vIEwDIDLoad() {        super.vIEwDIDLoad()        // Do any additional setup after loading the vIEw.    }    overrIDe var representedobject: AnyObject? {        dIDSet {        // Update the vIEw,if already loaded.        }    }}

STEP3

打开Main.storyboard，在VIEwController中拖入Label



STEP4

修改VIEwController.swift代码

上述的NSTextFIEld后面的叹号，它被称为隐式拆封的可选类型，是一种特殊类型,指出变量可能有值,也可能为nil。Swift运行 环境不喜欢访问值为nil的变量,因此Swift程序员必须知晓变量的值,尤其在其可能为nil时。
将变量声明为隐式拆封的可选类型相当于告诉Swift编译器,你承诺在该变量的值为nil时绝 不会访问它。这是你与编译器签订的一个合约,你必须遵守。如果你不遵守,在变量为nil时访 问它,将引发运行阶段错误,导致应用程序停止运行

另外也可以开启两个视图直接拖入例如：


STEP5

链接UI与代码部分，将TextFIEld右键，选择new referencing Outlets点加号指向VIEwController,在d出的选项里面选择timestamp,同样方式选择到label上。


绑定按钮的click事件


STEP6

点击上方的三角箭头运行程序



总结

以上是内存溢出为你收集整理的Swift笔记-让你2小时学会Swift全部内容，希望文章能够帮你解决Swift笔记-让你2小时学会Swift所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。