Swift学习笔记|swift基本语法

最新推荐文章于 2016-01-26 15:24:57 发布

SunnyHughLee

最新推荐文章于 2016-01-26 15:24:57 发布

阅读量455

点赞数

分类专栏： IOS development exploration

本文链接：https://blog.csdn.net/zesicus/article/details/40922237

版权

IOS development exploration 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

1、输出语句：

println("Hello, world! ")

2、定义变量：

var i = 3 
i =10

定义常量：

let c = 10

字符串变量：

var str = "Hello "
var s:String = "World." //类型说明，省略则由编译器自行判断。
println(str)

可选变量

//字符转换成整数，但是类似"Hello, world!"不能转换。
let possibleNumber = "Hello"
let convertedNumber = possibleNumber.toInt()
//convertedNumber 被推测为"Int?"可选型常量
if (convertedNumber != nil) {
    println("It's ok to converted to be: \(convertedNumber)")
} else {
    println("Cannot coverted, result: \(convertedNumber)")
}
//可选绑定
var possibleNumber2: String? = "if可选绑定"
if let constNumber = possibleNumber2 {//判断possibleNumber2是否为空
    println(constNumber)
}

类型别名

typealias myType = UInt16
var maxTest = myType.max
println(maxTest)

3、元组

let http404Error = (404, "Page not found")
let (returnCode, returnMessage) = http404Error
println("Error page return code is \(http404Error.0).")
println("Error page return code is \(returnCode).")
println("The message is '\(returnMessage)'.")
let http200Status = (statusCode: 200, statusMessage: "OK")
println("Status code is \(http200Status.statusCode)")

＊计数共多少字符函数countElements

let names = "Anne, Tom."
println(countElements(names))

4、字符串连接：

var i = 100
var st0 = "Hello "
var st1 = "World"
var st2 = st0 + st1
var st3 = "\(st2) I'm new here \(i)" //字符串的连接
println(st3)

5、数组

var shoppingList = ["Eggs","Milk"]
//数组增添新项目
shoppingList.append("Flour")
shoppingList += ["Baking Powder"]
//改变数组位置值
var firstItem = shoppingList[0]
println(shoppingList)
println(firstItem)
shoppingList[0] = "Six eggs"
shoppingList[1...2] = ["Bananas","Apples"]
println(shoppingList)
shoppingList.insert("yoghourt", atIndex: 0)
println(shoppingList)
//删除数组某位置值
let yoghourt = shoppingList.removeAtIndex(0)
println(shoppingList)
//输出数组内元素
for item in shoppingList {
    println(item)
}
var eightDoubles = [Float](count: 3, repeatedValue: 0.0)
println(eightDoubles)

6、字典

var airports: Dictionary<String, String> = ["TYO": "Tokyo", "DUB": "Dublin"]
println(airports)
//添加新数据项
airports["LHR"] = "London"
println(airports)
//Modify the value.
airports["LHR"] = "London Heathrow"
println(airports)
//Another way to modify the value.
if let oldValue = airports.updateValue("Dublin Internation", forKey: "DUB") {
    println(oldValue)
}
println(airports)
//Remove the value
airports["APL"] = "Apple Internation"
airports["APL"] = nil
println(airports)
if let removedValue = airports.removeValueForKey("DUB") {
    println(airports)
    println("The removed airport's name is \(removedValue).")
}
//Dictionary traversal
for (airportCode, airportName) in airports {
    println("\(airportCode): \(airportName)")
}
for airportCode in airports.keys {
    println("Airport code: \(airportCode)")
}
for airportName in airports.values {
    println("Airport name: \(airportName)")
}
//可以直接使用keys或者values属性直接构造一个新数组
let airportCode = Array(airports.keys)
println(airportCode)
let airportName = Array(airports.values)
println(airportName)
//Create a New Dictionary
var nameOfIntegers = Dictionary<Int, String>()
nameOfIntegers = [:]//清空字典～

7、控制流

//C样式for循环，不需要圆括号，此时声明的index只在for循环生命周期内有效
for var index = 0; index < 3; ++index {
    println(index)
}
//switch case 语句允许临时定义值
let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    println("On the x-axis with an x value of \(x)")
case (0, let y):
    println("On the y-axis with an y value of \(y)")
case let (x, y):
    println("Somewhere else at (\(x),\(y))")
}
//case 块模式可以使用where语句来判断额外的条件
let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
case let (x, y) where x == y:
    println("x == y")
case let (x, y) where x == -y:
    println("x == -y")
case let (x, y):
    println("just some arbitrary point")
}
//failthrough落下，相当于C语言case后不加break
let integerToDescribe = 5
var description = "The number \(integerToDescribe) is"
switch integerToDescribe {
case 2, 3, 5, 7, 11, 13, 17, 19:
    description += "a prime number, and also"
    fallthrough
default:
    description += " an integer."
}
println(description)
//Labeled Statements，改编 蛇与梯子，落在格25获胜
let finalSquare = 25
var board = [Int](count: finalSquare + 1, repeatedValue: 0)
board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
var square = 0
var diceRoll = 0
gameLoop: while square != finalSquare {
    if ++diceRoll == 7 { diceRoll = 1 }
    switch square + diceRoll {
    case finalSquare:
        break gameLoop//结束本次循环迭代
    case let newSquare where newSquare > finalSquare:
        continue gameLoop//结束本次循环迭代，并开始下一次循环迭代
    default:
        square += diceRoll
        square += board[square]
    }
}
println("Game over!")

8、方法（函数）

func sayHello (personName: String) -> String {
    let greeting = "Hello, " + personName + "!"
    return greeting
    //和return "Hello, " + personName + "!"是一样的。
}
println(sayHello("TheSix"))
//外部形参名，有益于代码的理解。
func join(string s1: String, toString s2:String, withJoin joiner:String) -> String {
    return s1 + joiner + s2
}
println(join(string: "Hello", toString: "world.", withJoin: ", "))
//外部形参名称速记，用＃作为前缀标记
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")
println(containsAVee)
//一个可变形参可接受0个或多个指定类型的值
//函数最多有一个可变形参，而且它必须出现在参数列表的最后，以避免使用多个形参调用函数引发歧义
func arithmeticMean(numbers: Double...) ->Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
println(arithmeticMean(1, 2, 3, 4, 5))
//常量形参和变量形参
//函数的形参默认是常量。试图改变会引发编译时错误。
//变量形参举例
func alignRight (var string: String, count: Int, pad: String) -> String {
    let amountToPad = count - countElements(string)
    for _ in 1...amountToPad {
        string += pad
    }
    return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, 10, "-")
println(paddedString)
//In-Out形参，如果想让函数改变形参值并保持调用结束形参值的改变
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), \(anotherInt)")
//作为形参的函数类型
func addTwoInts (a: Int, b: Int) -> Int {
    return a + b
}
var mathFunction: (Int, Int) -> Int = addTwoInts
func printMathResult (mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    println("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
//作为返回类型的函数类型
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)
println("Counting to zero:")
while currentValue != 0 {
    println("\(currentValue)...")
    currentValue = moveNearerToZero(currentValue)
}
println("zero!")

9、闭包

/*
闭包采取如下三种形式之一：
1.全局函数是一个有名字但不会捕获任何值的闭包
2.嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
3.闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包
*/
//闭包表达式
//sort函数
let willBeSortedNames = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
func compareTwoNames (s1: String, s2: String) -> Bool {
    return s1 > s2
}
//var reversed = sort(willBeSortedNames, >)
//Trailing闭包
let digitNames = [
    0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]
let strings = numbers.map {
    (var number) -> String in
    var output = ""
    while number > 0 {
        output = digitNames[number % 10]! + output
        number /= 10
    }
    return output
}
println(strings)