swift學習文檔(筆記)
更新時間：2014年09月13日 13:13:26 作者：jser
這篇文章主要介紹了學習swift的筆記，swift最近也比較熱，需要的朋友可以參考下
Swift是供iOS和OS X應用編程的新編程語言，基于C和Objective-C，而卻沒有C的一些兼容約束。Swift采用了安全的編程模式和添加現(xiàn)代的功能來是的編程更加簡單、靈活和有趣。界面則基于廣受人民群眾愛戴的Cocoa和Cocoa Touch框架，展示了軟件開發(fā)的新方向。
變量與常量
變量定義使用var，常量使用let，類型安全，有自動類型推導，注意賦值的=號兩邊必須有空格。變量和常量名是可以幾乎所有字符，這些都非常像javascript。中文編程一下牛逼了。
var a = 123 //a為Int let b = "helo" //b為String var 貓叫 ＝ "喵"
數字
- 十進制
- 二進制 0b101
- 八進制 0o5
- 十六進制 0x5
比較長的數字間可以加上_用來提高程序的可讀性，比如0_0其實就是0，_線不能加在開頭
布爾類型
true和false，流程控制if的時候，判斷語句返回必須是一個Bool值，比如：
let i = 1
if i {
//編譯報錯
}
這樣就可以通過
if i == 1 {
}
它不像js里會有自動類型轉換
類型別名
給現(xiàn)在的類型添加別名，同樣可以提高程序的可讀性，如
typealias 音頻采樣 = UInt16
可以在別的地方使用 var 已發(fā)現(xiàn)的最大振幅 = 音頻采樣.min
元組
它可以是一組值，這些值不必是相同的類型，例如，定義我自己：
var jserme = ("183cm", 26, "76kg")
可以像數組一樣訪問
println(jserme.0) //返回183cm
元組還原為獨立的變量或者常量
let jserme = ("183cm",26,"76kg")
let (身高, 年齡, 體重) = jserme
println("身高是 \(身高)")
也可以給每個值命名（這就像在JS里把數組搞成了對象了。。。）
let jserme = (身高:"183cm",年齡:26,體重:"76kg")
println("身高是 \(jserme.身高)")
字符串
字符串字面量只能用""來定義，String本質上是Character的有序集合。
for char in "一言既出"{
println(char)
}
/*
一
言
既
出
*/
字面量與判斷是否為空
var 字符串 = "我是字符串"
var 空字符串 = ""
if 空字符串.isEmpty {
println("這是一個空的字符串")
}
if 空字符串 == "" {
println("這是一個空的字符串")
}
字符串實例有兩個方法hasPrefix與hasSuffix，如：
var 成語數組 = [
"一言既出",
"一觸即發(fā)",
"一呼百應",
"一槌定音",
"一無所有",
"一生一世",
"一見鐘情"
]
var count = 0
for 成語 in 成語數組 {
if(成語.hasPrefix("一")){
count++
}
}
println(count) //輸出7
與js一樣，string也是傳值引用，下面的兩個變量的修改不會影響到彼此
var 一串 = "我是字符串一"
var 二串 = 一串
二串 = "我是字符串二"
println("字符串一:\(一串)， 字符串二:\(二串)")
區(qū)間運算符
閉區(qū)間使用a...b，從a到b，包含a與b，半區(qū)間a..b，從a到b，不包含b，例如：
var 成語數組 = [
"一言既出",
"一觸即發(fā)",
"一呼百應"
]
for i in 0..成語數組.count {
println("第\(i)個成語是:\(成語數組[i])")
}
//這里如何使用...會報錯，因為成語數組[3]是沒有值的
兩種集合,array 和 dictionaries
相對于js對數組和對象成員松散的要求，swift要求數組和dictionaries里成員類型必須一致
var 購物清單: String[] = ["雞蛋", "牛奶"] //也可以是下面的這樣 //var 購物清單 = ["雞蛋", "牛奶"]
數組的修改可以使用append方法或者+=
var 購物清單 = ["雞蛋", "牛奶"]
購物清單.append("蘋果")
購物清單 += "草莓"
println("\(購物清單)") //[雞蛋, 牛奶, 蘋果, 草莓]
數組的獲取，可以通過索引，也可以通過區(qū)間運算符
var 購物清單 = ["雞蛋", "牛奶"]
println("\(購物清單[0])") //雞蛋
println("\(購物清單[0..1])") //[雞蛋]
println("\(購物清單[0...1])") //[雞蛋, 牛奶]
println("\(購物清單[0...2])") //[雞蛋, 牛奶, ]
dictionaries的定義
var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"] //也可以簡化為 //var airports = ["TYO": "Tokyo", "DUB": "Dublin"]
它的修改與讀取使用[],而不能使用.
airports["BJ"] = "Beijin"
控制語句
如前面的幾個例子所示，控制語句的條件不像js有小括號
for var index = 0; index < 3; index++ {
println("index is \(index)")
}
//index is 0
//index is 1
//index is 2
函數
函數的聲明與調用：
func sayHello(personName: String) -> String {
let greeting = "Hello, " + personName + "!"
return greeting
}
println(sayHello("jserme"))
無返回的函數，其實質是返回一個Void，它等同于一個空的元組()
多返回值的函數與默認參數：
func info(word:String = "aha") -> (length:Int, containA:Bool){
var containA = false
for char in word {
if( char == "a") {
containA = true
break
}
}
return (word.utf16count, containA)
}
println(info(word: "波波")) //(2, false)
println(info()) //(3, true)
便于閱讀的外部參數名，在參數定義之前，與參數定義以空格隔開，如下面的多個參數
func join(string s1: String, toString s2: String, withJoiner joiner: String)
-> String {
return s1 + joiner + s2
}
//調用的時候
join(string: "hello", toString: "world", withJoiner: ", ")
// returns "hello, world"
參數名與外部參數名一致，可以給參數名加#標識：
func containsCharacter(#string: String, #characterToFind: Character) -> Bool {
for character in string {
if character == characterToFind {
return true
}
}
return false
}
let containsAVee = containsCharacter(string: "aardvark", characterToFind: "v")
// containsAVee equals true, because "aardvark" contains a "v"
函數的參數是常量，不可以修改，如果在函數內修改，變量定義前加var
func alignRight(var string: String, count: Int, pad: Character) -> String {
let amountToPad = count - countElements(string)
for _ in 1...amountToPad {
string = pad + string
}
return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, 10, "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"
如果想在函數內修改傳入的參數，可以使用inout關鍵字來標識，傳入的參數需要前綴&，這內部實現(xiàn)應該是指針。
func swapTwoInts(inout a: Int, inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3"
函數類型，可以像js一樣使用函數作為參數及返回值
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
} //函數類型為 (Int, Int) -> Int
func multiplyTwoInts(a: Int, b: Int) -> Int {
return a * b
}//函數類型為 (Int, Int) -> Int
//接收名為mathFunction的函數類型
func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"
//返回函數類型
func stepForward(input: Int) -> Int {
return input + 1
}
func stepBackward(input: Int) -> Int {
return input - 1
}
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
return backwards ? stepBackward : stepForward
}
var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function
閉包
函數與它包含的上下文的變量在一起稱為閉包。如sort函數:
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func backwards(s1: String, s2: String) -> Bool {
return s1 > s2
}
var reversed = sort(names, backwards)
println(reversed)
// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]s
使用閉包可以表示為:
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
var reversed = sort(names, {(s1:String, s2:String) -> Bool in
return s1 > s2
})
println(reversed)
// reversed is equal to ["Ewa", "Daniella", "Chris", "Barry", "Alex"]
也可以簡化為
let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
var reversed = sort(names, { s1, s2 in s1 > s2 } )
println(reversed)
枚舉
通過下面的語法聲明
enum Barcode {
case UPCA(Int, Int, Int) = (1,2,3)
case QRCode(String) = "hello"
}
類與結構體
推薦使用首字母大寫來命名
struct Resolution {
var width = 0
var heigth = 0
}
class VideoMode {
var resolution = Resolution()
var interlaced = false
var frameRate = 0.0
var name: String?
}
生成實例：
let someResolution = Resolution() let someVideoMode = VideoMode()
屬性訪問與修改，使用.語法：
println("The width of someVideoMode is \(someVideoMode.resolution.width)")
someVideoMode.resolution.width = 12880
println("The width of someVideoMode is now \(someVideoMode.resolution.width)")
結構體有自動成員初始化器，類實例沒有：
let vga = resolution（width:640, heigth: 480）
結構體與枚舉都是值類型，類是引用類型
對于引用了同一個實例的值，可以使用===和!==來進行判斷
延遲屬性,@lazy，設置在調用的時候才初始化特定的屬性
class DataImporter {
/*
DataImporter 是一個將外部文件中的數據導入的類。
這個類的初始化會消耗不少時間。
*/
var fileName = "data.txt"
// 這是提供數據導入功能
}
class DataManager {
@lazy var importer = DataImporter()
var data = String[]()
// 這是提供數據管理功能
}
let manager = DataManager()
manager.data += "Some data"
manager.data += "Some more data"
// DataImporter 實例的 importer 屬性還沒有被創(chuàng)建
類、結構體、枚舉都可以通過設置setter與getter來
struct AlternativeRect {
var origin = Point()
var size = Size()
var center: Point {
get {
let centerX = origin.x + (size.width / 2)
let centerY = origin.y + (size.height / 2)
return Point(x: centerX, y: centerY)
}
set { //這里setter 沒有定義表示新值的參數名，則可以使用默認名稱newValue
origin.x = newValue.x - (size.width / 2)
origin.y = newValue.y - (size.height / 2)
}
}
}
只讀屬性去掉get與set
屬性監(jiān)視可以使用willset和didset來處理
類型屬性有點像靜態(tài)變量，以static關鍵字聲明
struct SomeStructure {
static var storedTypeProperty = "Some value."
static var computedTypeProperty: Int {
// 這里返回一個 Int 值
}
}
下標
類、結構體、枚舉都可以有下標，它有像給它們增加了一個快捷方式，如下：
struct TimesTable {
let multiplier: Int
subscript(index: Int) -> Int {
return multiplier * index
}
}
let threeTimesTable = TimesTable(multiplier: 3)
println("3的6倍是\(threeTimesTable[6])")
// 輸出 "3的6倍是18"
繼承
定義一個類
class Vehicle {
var numberOfWheels: Int
var maxPassengers: Int
func description() -> String {
return "\(numberOfWheels) wheels; up to \(maxPassengers) passengers"
}
init() {
numberOfWheels = 0
maxPassengers = 1
}
}
繼承類
class Bicycle: Vehicle {
init() {
super.init()
numberOfWheels = 2
}
}
重寫屬性與方法
class Car: Vehicle {
var speed: Double = 0.0
override var speed: Double {
get {
return super.speed
}
set {
super.speed = min(newValue, 40.0)
}
}
init() {
super.init()
maxPassengers = 5
numberOfWheels = 4
}
override func description() -> String {
return super.description() + "; "
+ "traveling at \(speed) mph"
}
}
防止重寫，在方法與屬性前加關鍵字@final，編譯時會出錯
構造函數
聲明里可以寫多個init，這有點像重載
struct Celsius {
var temperatureInCelsius: Double = 0.0
init(fromFahrenheit fahrenheit: Double) {
temperatureInCelsius = (fahrenheit - 32.0) / 1.8
}
init(fromKelvin kelvin: Double) {
temperatureInCelsius = kelvin - 273.15
}
}
let boilingPointOfWater = Celsius(fromFahrenheit: 212.0)
// boilingPointOfWater.temperatureInCelsius 是 100.0
let freezingPointOfWater = Celsius(fromKelvin: 273.15)
// freezingPointOfWater.temperatureInCelsius 是 0.0”
類的析構
有些地方叫反初始化，很別扭的名字哦
class Player {
var coinsInPurse: Int
init(coins: Int) {
coinsInPurse = Bank.vendCoins(coins)
}
func winCoins(coins: Int) {
coinsInPurse += Bank.vendCoins(coins)
}
deinit {
Bank.receiveCoins(coinsInPurse)
}
}
var player = Player(coins:200)
player = nil //調用deinit方法
擴展
對于類、結構體、枚舉，可以擴展它們的一切
class Player{
var age:Int
}
extension Player{
func repetitions(task: () -> ()) {
for i in 0..self {
task()
}
}
}
協(xié)議
其實就是接口描述
protocol SomeProtocol {
var mustBeSettable: Int { get set }
var doesNotNeedToBeSettable: Int { get }
func someTypeMethod()
}
協(xié)議繼承
protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
// protocol definition goes here
}
泛型
這個函數的泛型版本使用了節(jié)點類型命名（通常此情況下用字母T來表示）來代替實際類型名（如Int、String或Double）。節(jié)點類型名并不是表示T必須是任何類型，但是其規(guī)定a和b必須是同一類型的T，而不管T表示任何類型。只有swapTwoValues函數在每次調用時所傳入的實際類型決定了T所代表的類型。
func swapTwoValues<T>(inout a: T, inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
運算符重載
這里演示重載+號運算符
struct Vector2D {
var x = 0.0, y = 0.0
}
@infix func + (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y + right.y)
}
- 前置運算符 @prefix
- 后置運算符 @postfix
- 組合賦值運算符 @assignment
- 比較運算符 @infix
@prefix @assignment func ++ (inout vector: Vector2D) -> Vector2D {
vector += Vector2D(x: 1.0, y: 1.0)
return vector
}
自定義運算符
個性的運算符只能使用這些字符 / = - + * % < >！& | ^。~
operator prefix +++ {}
@prefix @assignment func +++ (inout vector: Vector2D) -> Vector2D {
vector += vector
return vector
}
結合性(associativity)的值默認為none,可用left,right,none，優(yōu)先級(precedence)默認為100。
operator infix +- { associativity left precedence 140 }
func +- (left: Vector2D, right: Vector2D) -> Vector2D {
return Vector2D(x: left.x + right.x, y: left.y - right.y)
}
let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
// plusMinusVector 此時的值為 (4.0, -2.0)
相關文章
這篇文章主要為大家詳細介紹了Swift數組詳細用法,具有一定的參考價值，感興趣的小伙伴們可以參考一下2016-11-11
這篇文章主要介紹了用Swift構建一個簡單的iOS郵件應用的方法,包括查看和標記已讀等基本的郵件應用功能,需要的朋友可以參考下2015-07-07
內存管理和異常處理在任何編程語言中都是核心概念。盡管有很多教程解釋了Swift自動引用計數的基本原理，但我發(fā)現(xiàn)沒有一個可以從編譯器的角度對其進行解釋。在本文中，我們將通過詳細代碼列舉學習Swift內存管理與異常處理2021-11-11
這篇文章主要介紹了Swift中 ！和 ？的區(qū)別及使用的相關資料,需要的朋友可以參考下2016-12-12
類型占位符是swift5.6中引?的?個新功能,在處理稍微復雜的通?類型時,它可能真的很有用,這篇文章主要給大家介紹了關于Swift類型占位符的相關資料,需要的朋友可以參考下2022-06-06
在Swift中使用Objective-C編寫類、繼承Objective-C類
這篇文章主要介紹了在Swift中使用Objective-C編寫類、繼承Objective-C類等操作方法介紹,需要的朋友可以參考下2014-07-07
這篇文章主要給大家介紹了關于Swift5中從原始文本創(chuàng)建字符串的相關資料，文中通過示例代碼介紹的非常詳細，對大家學習或者使用Swift5具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2019-06-06
支持泛型意味著可以在規(guī)定參數類型的情況下更靈活地編寫程序,也是Swift語言先進而又強大的體現(xiàn),這里我們就來解析Swift中的泛型支持與使用:2016-07-07
每當看到新的編程語言我總是會有相當大的興趣，所以下面這篇文章主要給大家介紹了關于Swift3遷移至Swift4可能遇到的問題，文中通過示例代碼介紹的非常詳細，需要的朋友可以參考借鑒，下面來一起學習學習吧2018-06-06
懸浮操作按鈕（Floating Action Button, FAB）是一種在 Android 和 Material Design 中使用的 UI 元素,它用于觸發(fā)特定屏幕的主要操作,下面我們就來詳細介紹一下如何在SwiftUI中創(chuàng)建懸浮操作按鈕,需要的朋友可以參考下2023-10-10