Swift 3学习笔记第一篇（语法概览）

1.简单值

let 声明常量，var 声明变量,在变量名后面跟上:类型 来显示声明，不跟的话编译器会根据类型自动做出类型判断

/*
 * 1.声明
 */
//: 隐身声明
let interNum = 50

//: 显示声明
let expliceNum :Double = 40

2.字符串拼接

String（） 可以显示转换`,或者用反斜杠+（）来表示占位符，进行字符串转换

/*
 * 2.字符串拼接
 */
//:1. 字符串拼接（数字转字符串）
let lable = "mmikejing"

let width = 30

let lableWidth = lable + String(width)
print(lable + "\(width)")

//:2.字符串拼接（\()）
let xiaoming = 10
let xiaohong = 20
let sumAge = "all ages is \(xiaoming + xiaohong)"

let xiaohei :Double = 99.1
let sumLeave = "xiaohei de age \(xiaohei)"

3.字典和数组创建访问

字典和数组都是用[] 进行包装，字典里面是键值对，[key:value] 数组里面是单个值[value],其中空数组的类型声明可以是[] 和 Array<Int>，值得注意的是字典的声明时[:] 和 Dictionry<String,Int>,后面是逗号隔开，而不是冒号了

//: 1.数组
var shoppingList = ["ta","he","she","her","we"]
print(shoppingList[1])
shoppingList[1] = "666"
print(shoppingList)


//: 2.字典
var dic :Dictionary = ["JSON":20,"LUSIA":30]
print(dic["JSON"]!) // 不加！是optional(20),强行拆包
dic["MKJ"] = 100
print(dic);

//: 3.空数组和空字典的创建
let emptyArray = [String]()  // 类型 + （）
var emptyArray1 = Array<Int>() // 类型 + （）
var emptyArray2:Array<Int> = [] // 显示声明 + 直接[]初始化


let empryDict = [String:Float]() // 类型 + ()
let empryDict1 = Dictionary<String,Float>() // 字典(,分割) + ()
let emtpryDict2:Dictionary<String,Float> = [:]

4.控制流 if else for-in

1.if-else中判断语句一定要是个表达式，不能像OC一样直接写一个例如，if（entity）上去，swift中不支持隐式转换
2.switch可以是任何类型
3.for-in中..< 不包含右区间，... 包含右区间

/*
 * 4.控制流 if switch for-in  while  do while
 */

//: 示例 1   if else
let scroes = [10,50,80,98,17]
var teamScroes = 0
for score in scroes {
    if score > 50 { // ---> if语句中必须是一个bool表达式  不能直接写score，系统不会进行默认的和0判断
        print(score)
        teamScroes += 3
    }
    else
    {
        teamScroes += 1
    }
}
print(teamScroes)


//: 示例 2  let常量的nil判断
var optionStr :String? = "woshiyizhizhu"
print(optionStr == nil)

// requires a contextual type
// let hehe = nil  
// let声明的变量不能为nil，因此可以拿这个点来做if判断，因为swift不可以直接把值弄上去，系统不会自动和0进行比对，一定要给表达式

var optionalStr : String? = "mikejing"
var greeting = "Hello!"
if let name = optionalStr {
    greeting = greeting + optionalStr!
}
else
{
    greeting = greeting + "chengjinjiao"
}
print(greeting)


//: 示例 3 switch支持任意类型的数据以及各种比较操作——不仅仅是整数以及测试相等。
// 声明'let'可用于匹配某部分固定值的模式 这句话有待琢磨。。。
let vagetable = "red tiger"
var vagetaleComment = ""
switch vagetable {
case "hehe":
    vagetaleComment = "add some numb"
case "wuyu":
    vagetaleComment = "that is a pig"
case let x where x.hasPrefix("red"):
    vagetaleComment = "yes get it \(x)"
default:
    vagetaleComment = "done"
}
print(vagetaleComment)

//: 示例 4 for in字典  查找最大值以及对应的key
let interestingNums = ["Prime":[1,2,3,4,5,6,7,40],"Fibonacci":[1,1,2,3,5,8],"Squre":[1,4,9,16,25,36]]
var largest = 0
var largestKey :String? = nil
for (key,value) in interestingNums {
    for num in value {
        if num > largest {
            largest = num
            largestKey = key
        }
    }
}
//print(largestKey! + " + " + String(largest))
print(largestKey! + "+" + "\(largest)")

//: 示例 5 简单的循环使用
// ..<不包含最大   ...包含最大值
var firstForLoop = 0
for i in 0..<4 {
    firstForLoop += i
}
print(firstForLoop)

5.函数

语法：(argv:类型,argv:类型)->(类型)

/*
 * 5.函数
 */
//: 示例1 基本函数
func greet(name:String,today:String,food:String) -> String{
    return "Hello \(name) today is \(today) eat \(food) im very happy"
}

print(greet(name: "MKJ", today: "4月10日", food: "��肉干"))



//: 示例2 利用元祖返回多个值
// 参数的值对应的写法的两种不同表现形式
// 例如是数组  1.scroes:[Int]  2.scroes:Array<Int>
// 例如是字典 1.scroes:[String:Int]  2.Dictionary<String,Int> 注意字典这里用的是逗号，不是冒号
func calculateStatics(scroes:Array<Int>) -> (min:Int , max:Int ,sum:Int)
{
    var min = scroes[0]
    var max = scroes[0]
    var sum = 0
    for sc in scroes {
        if sc > max {
            max = sc
        }
        else if sc < min {
            min = sc
        }
        sum += sc
    }
    return(min,max,sum)
}
let result = calculateStatics(scroes: [1,3,5,45,4])
print("max--->\(result.max),min--->\(result.min),sum--->\(result.sum)" + "--->mikekeing")

6.闭包

1.定义：函数可以被嵌套，被嵌套的函数可以访问外侧函数的变量
2.函数作为返回值() -> ((Int) -> Int) 这里注意的是，3以后参数要加括号，之前貌似不需要加括号

/*
 * 5.闭包  
 * 函数可以被嵌套，被嵌套的函数可以访问外侧函数的变量
 */
//: 示例1 最简单的闭包 函数嵌套
func closure_func () -> Int{
    var x = 0
    func add(){
        x += 10
    }
    add()
    return x
}
print("\(closure_func())")


//: 示例2 函数作为返回值  注意这里需要用函数作为返回值的时候参数一定要用括号，swift2.3的时候貌似不需要多好都行
//: error ---> single argument function types require parentheses
func makeImprove() -> ((Int) -> Int)
{
    func addCount(number:Int) -> Int{
        return number + 2
    }
    return addCount
}

var method = makeImprove()
print("\(method(10))")


//: 示例3 函数作为参数
func hasAnyMatch(list:Array<Int>,condition: (Int) -> Bool) -> Bool
{
    for score in list {
        if condition(score) {
            return true
        }
    }
    return false
}


func largeThan(number:Int) -> Bool
{
    return number > 100
}

var counts = [54,53,67,37,9,75]

print("是否有值大于100--->\(hasAnyMatch(list: counts, condition: largeThan))")

/*
 * 注意：1.闭包就是函数内嵌，内部函数可以访问其外部变量
 *      2.函数作为参数或者作为返回值，表达函数指针的时候一定要把参数类型加上括号，不然就error
 */

闭包的语法以及缩写
1.用{} 来创建闭包
2.内部用in 进行函数声明和函数体的分离{(参数)->(返回值) in 函数体}
3.用$0,$1 来进行函数参数和返回值的和in的省略，直接调用$0函数体 来进行闭包的实现

//: 示例4 函数其实就是一个特殊的闭包，使用{}来创建一个闭包，然后使用in 来分离参数返回值和函数体
let testResult = counts.map { (number:Int) -> Int in
    let result =  3 * number
    return result;
}
print(testResult)

// 示例5 匿名函数体的创建和使用例子 使用$0  $1来省略参数类型返回值和in，保留函数体
let cast = ["Vibim","John","Kibui","Koikis","YiYOLLLLLL"]
let lowcaseNames = cast.map {$0.lowercased()}
print(lowcaseNames)
let lowcaseCount = cast.map {$0.characters.count}
print(lowcaseCount)


// 示例6 正常和缩写的对比
let sortNumber = [1,55,6,3,75,43,73,4,64,66]
let sortedNum = sortNumber.sorted { (a, b) -> Bool in
    return a < b
}
print(sortedNum)


let sortenNum1 = sortedNum.sorted {$0 > $1}
print(sortenNum1)


// 示例7 重写闭包 对所有的奇数返回0
func testOdd(list:[Int]) -> [Int]
{
    var oddList = Array<Int>()
    func isOdd(num:Int) -> (){
        oddList.append(num % 2 == 0 ? num : 0)
    }
    for value in list {
        isOdd(num: value)
    }
    return oddList
}
print(testOdd(list: sortNumber))

7.类与对象的创建

通过class 类名 ： 父类名，协议 的语法声明，内部可以有属性，方法，值得注意的时候get和set方法的写法

// 类与对象的创建
// 形状基础类
class BaseShape {
    // 可以声明的时候初始化
    var numberOfSide:Int = 0
    var name:String
    init(name:String) {
        // 也可以析构的时候设置
        self.name = name
    }
    func baseDescription() -> String {
        return "a shape with \(numberOfSide) sides."
    }
}
var shape = BaseShape(name:"base shape")
shape.numberOfSide = 100
print(shape.baseDescription())

// 正方形
class Square : BaseShape{
    var sideLength:Double
    init(sideL:Double,name:String) {
        self.sideLength = sideL
        super.init(name: name)
        numberOfSide = 4
    }
    func areaSquare() -> Double {
        return sideLength * sideLength
    }
    override func baseDescription() -> String {
        return "square shpe with \(self.numberOfSide) sides."
    }
}

var squareShape = Square(sideL:8.8,name:"正方形")
print(squareShape.name + "area-->\(squareShape.areaSquare())  "+squareShape.baseDescription())

// 圆形
class Circle : BaseShape{
    var radi :Double
    init(radi:Double,name:String) {
        self.radi = radi
        super.init(name: name)
        self.numberOfSide = 1000
    }

    func areaCircle() -> Double {
        return 2 * 3.14 * radi * radi
    }

    var perimeter:Double{
        get{
            return 2 * 3.14 * radi * radi
        }
        set{
            self.radi = newValue
        }
    }

    override func baseDescription() -> String {
        return "Circle shpe with \(self.numberOfSide) sides."
    }

}

var circleShape = Circle(radi:5,name:"圆")
print(circleShape.name + "area-->\(circleShape.areaCircle())  "+circleShape.baseDescription())
circleShape.perimeter = 10.0
print(circleShape.name + "area-->\(circleShape.perimeter)  "+circleShape.baseDescription())

8. 枚举

// 枚举
enum Rank:Int{
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack,Queen,Kink
    func comparision(a:Rank) -> Bool {
        return self.rawValue > a.rawValue
    }

    func descriptionSimple() -> String {
        switch self {
        case .Ace,.Two, .Three, .Four, .Five, .Six, .Seven, .Eight, .Nine, .Ten:
            return "ACE"
        case .Jack:
            return "JACK"
        case .Queen:
            return "QUEUE"
        case .Kink:
            return "KINK"
        default:
            return String(self.rawValue)
        }
    }
}

print("左值大于右值？--->\(Rank.Jack.comparision(a: Rank.Six))   " + Rank.Four.descriptionSimple())
Rank.Queen.rawValue // 正向装换
Rank(rawValue:12)?.descriptionSimple() // 逆向转换


// 枚举无非就是指定一个值 一个引用针对某一个值  元祖的参数方式有所不同
enum ServerResponse {
    case Result(String, String)
    case Error(String)
}
// 创建第一个
let success = ServerResponse.Result("6:00 am", "8:09 pm")
// 创建第二个
let failure = ServerResponse.Error("Out of cheese.")

switch success {
case let .Result(sunrise, sunset):
    let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
    let serverResponse = "Failure...  \(error)"
}

9.协议和扩展

// 定义
protocol SomeProtocol {
// 这里是协议的定义部分
}
// 创建
struct SomeStructure: FirstProtocol, AnotherProtocol {
// 这里是结构体的定义部分
}

// 拥有父类的写法
class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
// 这里是类的定义部分
}
它只指定属性的名称和类型。此外，协议还指定属性是只读的还是可读可写的。
协议通常用 var 关键字来声明变量属性，在类型声明后加上 { set get } 来表示属性是可读可写的，只读属性则用 { get } 来表示

// 协议的方法要求 不需要大括号和方法体。
protocol RandomNumberGenerator {
func random() -> Double
}


看最简单的示例

protocol sampleProtocol{
    // 任何sampleProtocol类型都得有一个只读的protocolProperty属性，类型为String 不能通过setter进行设值，只getter进行取值 计算类型
    var protocolProperty:String {get}
    // 结构体和枚举是值类型。默认情况下，值类型的属性不能在它的实例方法中被修改  mutating
    // 实现协议中的 mutating 方法时，若是类类型，则不用写 mutating 关键字。而对于结构体和枚举，则必须写 mutating 关键字  修改值类型关键字
    mutating func appending()
}

class ExampleEntity : sampleProtocol{
    var protocolProperty: String = "mikejing  "
    // 类是对象属性，有地址，因此可以在方法中直接进行值的修改
    func appending() {
        protocolProperty += "class option protocol"
    }
}
var entityE = ExampleEntity()
entityE.appending()
print(entityE.protocolProperty)

// struct和enum都是值类型，不能在方法中进行属性值得修改，如果需要修改，必须加上mutating关键字
struct StructValue : sampleProtocol{
    var protocolProperty :String = "chengjingjiao  "
    mutating func appending() {
        protocolProperty += "struct option protocol"
    }
}

var structE = StructValue()
structE.appending()
print(structE.protocolProperty)

// 扩展方法 扩展int类型，自增一倍
extension Int : sampleProtocol{
    var protocolProperty: String{
        return "the number \(self)"
    }
    mutating func appending() {
        self += self
    }
}
var intNum = 200
intNum.appending()

extension String {
    var banana : String {
        let shortName = String(characters.dropFirst())
        return "\(self) \(self) you are bitch \(shortName)"
    }
}

let bananaName = "Jimmy".banana

笔记地址，每周更新一点