【4858.com】Swift基础学习的总计,Swift语言中与C

By admin in 4858.com on 2019年4月20日

这一节将会涉嫌Swift中其它的关于函数的采纳,那个剧情囊括有:

那1节将会提到Swift中别的的关于函数的施用,这几个剧情囊括有:

函数

前些天读书的内容是有关函数、闭包的知识.
1.函数

暗中同意参数值和可变参数值、常量参数、再次回到函数类型和函数嵌套:

默许参数值和可变参数值、常量参数、重临函数类型和函数嵌套:

函数基础

在斯维夫特中,函数前边要用func关键字注解,参数写在括号里,并用向右的箭头指向重返值的类别。

func sayHello(name: String?) -> String {
    return "Hello " + (name ?? "Guest")
}
var nickName : String? = nil
sayHello(nickName)
nickName = "MC"
sayHello(nickName)

//无参数,无返回值
func printHello1() {
    print ("Hello")
}
func printHello2() -> (){
    print ("Hello")
}
func printHello3() -> Void{
    print ("Hello")
}
  • 一.一 函数名、函数参数命名
    苹果编写函数的品格,正是函数的命名尤其类似于自然语句,有着不行强的可读性.符合规律大家的函数是是这么定义的:

1、默许参数值和可变参数值

1、私下认可参数值和可变参数值

行使元组重回七个值

时刻要记挂到函数的参数或再次来到类型为可选型的意况。

func findMaxAndMin (numbers:[Int]) -> (max:Int , min:Int)? {
    guard numbers.count > 0 else {
        return nil
    }
    var minValue = numbers[0]
    var maxValue = numbers[0]
    for number in numbers {
        minValue = minValue < number ? minValue : number
        maxValue = maxValue > number ? maxValue : number
    }
    //return返回的元组里面的各个分量可以不用指明变量名,如果指明必须与函数返回值声明的时候一样。
    return (maxValue , minValue)
}
var scores: [Int]? = [202,123,4324,543,123]
scores = scores ?? []
if let result = findMaxAndMin(scores!) {
    print("The max score is \(result.max)")
    print("The min score is \(result.min)")
}

对暗中同意参数值是指在函数的扬言中就早已定义了参数的初值,举例:

对默许参数值是指在函数的宣示中就已经定义了参数的初值,比如:

当中参数名与外部参数名

Swift的函数暗中认可会不显示第四个参数的参数名,但前边的参数会议及展览示出她们的参数名,但那不是相对的,前边会波及个中参数名和外部参数名的定义。

func sayHelloTo(name: String , greeting: String) -> String {
    return "\(greeting),\(name)!"
}
//sayHelloTo("Playground", "Hello")     //会报错
sayHelloTo("Playground", greeting: "Hello")

Swift中等高校函授数的每贰个参数都得以有3个之中参数名和叁个外部参数名。外部函数名用于调用函数时展现。未有外部参数名时,原来的参数名默以为内外参数名,当然大家也足以用下划线”_”来让函数被调用时不显得参数名。

func sayHelloTo(name: String , withGreetingWord greeting: String) -> String {
    return "\(greeting),\(name)!"
}
sayHelloTo("Playground", withGreetingWord: "Hello")


func mutiply (num1 : Int , _ num2 : Int) -> Int {
    return num1 * num2
}
mutiply(2, 3)

前后参数名的采纳景况:往往是上边调用者来调用函数,使语义尤其显眼,苹果官方正是如此做的:

var arr = [1,2,3,4,5]
arr.insert(5, atIndex: 3)
max(2, 3)

补充:下划线”_”近日大家在for-in循环,switch语句和元组中都用到过,那里在函数参数名的时候也利用了。

func sayHelloTo(name: String, greeting: String) -> String {
    return "say \(greeting) to \(name)"
}

sayHelloTo("jf", greeting: "hello")
func sayHelloTo(name:String,greeting:String = “Hi”, punctuation:String = “!”){
}
在调用的时候可以是:
sayHelloTo(name:“PlayGround”, punctuation :“!!!”, greeting :“Hi”)
func sayHelloTo(name:String,greeting:String = “Hi”, punctuation:String = “!”){
}
在调用的时候可以是:
sayHelloTo(name:“PlayGround”, punctuation :“!!!”, greeting :“Hi”)

默许参数值与可变参数

当四个函数有暗中同意参数值时,调用函数的时候会多一种调用形式,即不呈现暗中认可参数名称,相应的参数值为暗中同意值。私下认可参数之间的逐一是能够改变的。暗许参数能够放在参数列表的终极,也得以不放在最终,但此刻要小心,当私下认可参数不在参数列表最终的时候,参数之间的调用顺序是不许改动的。

func sayHelloTo (name: String , withGreetingWord greeting: String = "Hello" , punctuation: String = "!") -> String{
    return "\(greeting), \(name)\(punctuation)"
}
sayHelloTo("MC")
sayHelloTo("MC", withGreetingWord: "Hi")
sayHelloTo("MC", withGreetingWord: "Hi", punctuation: "!!!")
sayHelloTo("MC", punctuation: "!!!")
sayHelloTo("MC", punctuation: "!!!" , withGreetingWord: "Hi")

对于三个函数来讲,最多只可以有二个变长参数类型

func mean( numbers: Double ...) -> Double {
    var sum: Double = 0
    //将变长参数当做一个数组看待
    for number in numbers {
        sum += number
    }
    return sum / Double(numbers.count)
}
mean(2)
mean (2,3,4,5)

参数:greeting 既是函数外部参数名,也是函数内部参数名
假如大家想要区分开,使得调用时,语义看起来更显明,又不会潜移默化内部函数的参数调用,那时大家应当这么写:

因为对有默许参数的函数来说,有暗中同意参数值的参数是足以替换顺序的,不过不提出如此使用。print函数正是有分割符和完工符开头值的函数。

因为对有暗许参数的函数来说,有默许参数值的参数是能够轮换顺序的,不过不建议那样使用。print函数正是有分割符和得了符初阶值的函数。

常量参数,变量参数与inout参数

在斯维夫特二.2中,函数参数表明为var将会发出3个告诫。在斯威夫特3.0中,该语法将被撤除。相当于说,对于函数的参数,大家将依旧钦命为inout类型,可能不钦命,默以为let参数。如果要求2个变量参数,则供给在函数体内标注:var
num = num。

func toBinary(num: Int) -> String {
    var num = num
    var res = ""
    repeat {
        res = String(num%2) + res;
        num /= 2
    }while num != 0
    return res
}
var x = 100
toBinary(x)     //1100100
x               //x的值并没有被改变

若要在函数内修改完2个值之后,在函数外这一个值照旧是被转移的,则要在函数参数类型上标明inout类型,并且在传参数的时候,参数后面要加3个取址符号”&”。

func swapTwoInts(inout a:Int , inout _ b:Int) {
    (a , b) = (b , a)
}
var x:Int = 1
var y:Int = 2
swapTwoInts(&x, &y)
x           //2
y           //1

【4858.com】Swift基础学习的总计,Swift语言中与C。留意:Swift里的数组,字典,集结等都是按值传递的。

func initArray(inout arr:[Int] , by value:Int) {
    for i in 0..<arr.count {
        arr[i] = value
    }
}
var arr = [1,2,3,4,5]
initArray(&arr, by: 0)
arr             //[0,0,0,0,0]
func sayHelloTo(name: String, withGreeting greeting: String) -> String {
    return "say \(greeting) to \(name)"
}

sayHelloTo("jf", withGreeting: "hello")

对变长的参数类型的函数来讲,

对变长的参数类型的函数来讲,

运用函数类型

在斯威夫特中等高校函授数也足以视作贰个变量,也有相应的类型,即函数型变量。

func add(a:Int , _ b:Int) -> Int {
    return a + b
}
let anotherAdd = add           //(Int, Int) -> Int类型
anotherAdd(3,4)
//无参数无返回值类型的函数类型可以有下面四种方式表示:
() -> ()
() -> Void
Void -> ()
Void -> Void

上面举一个在实质上编程中会用到函数类型的例子:

var arr:[Int] = []
for _ in 0..<100 {
    arr.append(random()%1000)
}
arr.sort()          //默认从小到大排序
arr.sort(<#T##isOrderedBefore: (Int, Int) -> Bool##(Int, Int) -> Bool#>)         
//里面可以传一个(Int, Int) -> Bool类型的函数来告诉数组怎么排序.

//从大到小
func biggerNumberFirst(a:Int , _ b:Int) -> Bool {
    return a > b
}
arr.sort(biggerNumberFirst)

//按照字符串的字典序进行排序
func cmpByNumberString(a:Int , _ b:Int) -> Bool {
    return String(a) < String(b)
}
arr.sort(cmpByNumberString)

//按照距离500最近的数排序
func near500(a:Int , _ b:Int) -> Bool {
    return abs(a - 500) < abs(b - 500)
}
arr.sort(near500)

再有壹种景况,函数名早已1二分鲜明了,那时候大家不要求函数外部参数名,该怎么定义呢,请看:

func mean(numbers : Double ...)-> Double {
    for number in numbers {
        sum+=number
    }
    return sum/Double(numbers.count)
}

调用可以是:
mean(2)
也可以是
mean(2,3,4,5,6)
func mean(numbers : Double ...)-> Double {
    for number in numbers {
        sum+=number
    }
    return sum/Double(numbers.count)
}

调用可以是:
mean(2)
也可以是
mean(2,3,4,5,6)

函数式编制程序开头

咱俩以改分系统为例来介绍那些章节的剧情:

//常用写法
func changeScores1(inout scores:[Int]){
    for (index , score) in scores.enumerate() {
        scores[index] = Int(sqrt(Double(score)) * 10)
    }
}

func changeScores2(inout scores:[Int]){
    for (index , score) in scores.enumerate() {
        scores[index] = Int(Double(score) / 150.0 * 100.0)
    }
}

var scores1 = [36,61,78,89,99]
changeScores1(&scores1)

var scores2 = [88,101,124,137,150]
changeScores2(&scores2)

//改进写法
func changeScores(inout scores:[Int] , by changeScore: (Int) -> Int){
    for (index , score) in scores.enumerate() {
        scores[index] = changeScore(score)
    }
}
func changeScores1(score:Int) -> Int{
    return Int(sqrt(Double(score)) * 10)
}
func changeScores2(score:Int) -> Int{
    return Int(Double(score) / 150.0 * 100.0)
}

数组内容的扩展:

//map
changeScores(&scores1, by: changeScores1)
scores1.map(changeScores1)
//返回值可以不仅仅是整型
func isPassOrFail(score: Int) -> String {
    return score < 60 ? "Fail" : "Pass"
}
scores1.map(isPassOrFail)

//filter
func fail(score: Int) -> Bool {
    return score < 60
}
scores1.filter(fail)

//reduce
var arr = [1,2,3,4,5]
func add(num1:Int , _ num2: Int) -> Int {
    return num1 + num2
}
arr.reduce(0, combine: add)
arr.reduce(0, combine: +)

func concatenate(str:String , num: Int) -> String {
    return str + String(num) + " "
}
arr.reduce("", combine: concatenate)
func mutiply(num1: Int, _ num2: Int) -> Int {
    return num1 * num2
}

mutiply(1, 3)

而是贰个函数只可以够有三个变长的参数。

然则二个函数只可以够有三个变长的参数。

归来函数类型与函数嵌套

函数能够看做再次来到值,并且函数内部能够嵌套函数:

//邮费选择
func tier1MailFeeByWeight(weight: Int) -> Int {
    return 1 * weight
}

func tier2MailFeeByWeight(weight: Int) -> Int {
    return 3 * weight
}

//总价钱
func feeByUnitPrice(price: Int , weight: Int) -> Int {
    func chooseMailFeeCalculationByWeightt(weight: Int) -> (Int) -> Int {
        return weight <= 10 ? tier1MailFeeByWeight : tier2MailFeeByWeight
    }
    let mailFeeByWeight = chooseMailFeeCalculationByWeightt(weight)
    return mailFeeByWeight(weight) + price * weight
}
  • 1.二 暗中同意参数值和可变参数值
    有私下认可参数值

 

 

闭包

二、常量参数

2、常量参数

闭包的基本功语法

斯维夫Terry面包车型客车闭包,跟大家OC里面包车型地铁block基本是1模一样的。闭包本质上正是函数。

var arr:[Int] = []
for _ in 0..<100{
    arr.append(random()%1000)
}
func biggerNumberFirst(a:Int , _ b:Int) -> Bool {
    return a > b
}
arr.sort(biggerNumberFirst)

//使用闭包
arr.sort({ (a:Int,b:Int) -> Bool in
    return a > b
})
// 建议有默认参数值的参数放在最后面
func sayHelloTo(name: String, withGreeting greeting: String = "Hello") -> String {
    return "say \(greeting) to \(name)"
}

sayHelloTo("dd")
sayHelloTo("jf", withGreeting: "hello")

与Java和C/C++分裂,斯威夫特不得以在函数中改换参数的值,因为传播参数的值的档案的次序注明是let,好的函数会尽量制止必要改动函数参数的值。

与Java和C/C++分裂,斯威夫特不可以在函数中更改参数的值,因为传播参数的值的花色证明是let,好的函数会尽量幸免需求更改函数参数的值。

闭包语法的简化

对于一句话的闭包,大家可以有如下的化简:

arr.sort({ (a:Int,b:Int) -> Bool in
    return a > b
})

arr.sort({ (a:Int,b:Int) -> Bool in return a > b})

arr.sort({ a , b in return a > b})

arr.sort({ a , b in a > b})

arr.sort({ $0 > $1})

arr.sort(>)

变长的参数类型,对于两个函数最多有三个变长参数类型

只是假如要改成参数的值,供给那样来声称:

但是只要要改造参数的值,须求那样来声称:

末尾闭包

当闭包为3个函数要传播的末梢多少个参数时,闭包能够写在括号的外界。

arr.sort({ a , b in return a > b})

arr.sort(){ a, b in
    return a > b
}

arr.sort{ a, b in
    return a > b
}
func sayHelloTo(names: String ..., withGreeting greeting: String) {
    for name in names {
        print("\(name), \(greeting)")
    }
}

sayHelloTo("jf", "DC", withGreeting: "Hello")
func toBinary(var num:Int)-> String {
    return num/2
}
func toBinary(var num:Int)-> String {
    return num/2
}

剧情捕获

前方我们所用的闭包,都以用来作为函数来选择的,但在有些场合下,闭包是有友好尤其的优势的。

//sort里面传入的函数类型是确定的,我们无法传递第三个参数,这时可以利用闭包的内容捕获功能来解决这个问题。
arr.sort(<#T##isOrderedBefore: (Int, Int) -> Bool##(Int, Int) -> Bool#>)

var arr:[Int] = []
for _ in 0..<100{
    arr.append(random()%1000)
}

arr.sort{ a, b in
    abs(a - 500) < abs(b - 500)
}

var num = 300

arr.sort{ a, b in
    abs(a - num) < abs(b - num)
}
  • 壹.三 常量参数、变量参数、inout参数
    一般,大家传入函数的参数是私下认可为常量参数,如若供给1个变量参数(事实上,由于面向函数的尺度,不建议表明架构2个函数包蕴有变量参数。),则要求在函数体内标注:var
    num = num.

将品种注解为var,

将项目申明为var,

闭包和函数是引用类型

前边我们说过,Swift中数组,字典和集结都以值类型,今后大家将触发到斯威夫特中的第2个引用类型。

func runningMetersWithMetersPerDay(metersPerDay: Int) -> () -> Int {
    var totalMeters = 0
    return {
        totalMeters += metersPerDay
        return totalMeters
    }
}

var planA = runningMetersWithMetersPerDay(2000)
planA()             //2000
planA()             //4000
planA()             //6000
var planB = runningMetersWithMetersPerDay(5000)
planB()             //5000
planB()             //10000
planB()             //15000
var anotherPlan = planB
anotherPlan()       //20000
//证明是引用类型
planB()             //25000

可是那样的改观只是在函数的内部改造,不过在函数的外界是不改换的,

唯独如此的改变只是在函数的当中更换,不过在函数的外围是不改造的,

// 十进制数转二进制
func toBinary(num: Int) -> String {
    var num = num

    var res = ""

    repeat {
        res = String(num % 2) + res
        num /= 2
    } while num != 0

    return res
}

toBinary(12)

那是因为那种办法是按值出流传的,不是引用传入,只是在函数的内部开展了copy

这是因为那种办法是按值出流传的,不是援引传入,只是在函数的在那之中举办了copy

inout参数:能够改造传入的值,做到按引用传入.

一经必要痛殴函数改动外部参数的值,须求增加inout

假诺必要痛殴函数退换外部参数的值,须求增多inout

// 交换两个整数
func swapTwoInts(inout a: Int, inout _ b: Int) {
    let t: Int = a
    a = b
    b = t
}

var x = 1
var y = 2

swapTwoInts(&x, &y) // 传入参数前加上&
x // 2
y // 1
func swapInt(inout a :Int, inout b : Int){
    (a,b) = (b,a)
}
var x : Int = 1
var y : Int = 2
swapInt(&x,&b)
func swapInt(inout a :Int, inout b : Int){
    (a,b) = (b,a)
}
var x : Int = 1
var y : Int = 2
swapInt(&x,&b)
  • 一.肆 函数型类型
    函数自己是足以被看成变量的

 

 

3、再次回到函数类型

三、再次来到函数类型

// 函数本身是可以被当做变量的
var array1 = ["F", "P", "C", "D", "A", "S"]
func stringSortDesc(a: String, _ b: String) -> Bool {
    return a > b
}

let array2 = array1.sort(stringSortDesc)
array2


func sayHelloTo(names: String ..., withGreeting greeting: String) {
    for name in names {
        print("\(name), \(greeting)")
    }
}

func toBinary(num: Int) -> String {
    var num = num

    var res = ""

    repeat {
        res = String(num % 2) + res
        num /= 2
    } while num != 0

    return res
}

// 函数变量
let tobinary: (Int)->String = toBinary
let sayhello: (String ...,String)->() = sayHelloTo

其壹也异常的粗略,重回的项目是函数就好了:

其1也很粗大略,再次来到的类别是函数就好了:

4858.com ,上边通晓伊始的函数式编制程序例子

func tire1 (weight : Int)-> Int {
}
func tire2 (weight : Int ) ->Int {
}
func choose (weight : Int) -> (Int) -> Int {
    return weight>10 ? tire1(weight) : tire2(weight)
}
func tire1 (weight : Int)-> Int {
}
func tire2 (weight : Int ) ->Int {
}
func choose (weight : Int) -> (Int) -> Int {
    return weight>10 ? tire1(weight) : tire2(weight)
}
var score = [99, 20, 60, 80, 30, 21]

// map
func isPassOrFail(score: Int) -> String {
    return score < 60 ? "Fail" :"Pass"
}

score.map(isPassOrFail)

// filter
func arrayLower60(score: Int) -> Bool {
    return score < 60
}

score.filter(arrayLower60)

// reduce
func concatenate(str: String, score: Int) -> String {
    return str + "\(score)" + " "
}

score.reduce("", combine: concatenate)

// 从大到小-转成字符串
score.sortInPlace { (score1, score2) -> Bool in
    return score1 > score2
}
score.reduce("", combine: concatenate)

 

 

  • 一.5 再次回到值为函数类型,函数嵌套
    例如:

四、函数的嵌套

四、函数的嵌套

func feeByPrice(price : Int,weight:Int)->Int {

  func choose (weight : Int) -> (Int) -> Int {
      return weight>10 ? tire1(weight) : tire2(weight)
  }
return ...
}
func feeByPrice(price : Int,weight:Int)->Int {

  func choose (weight : Int) -> (Int) -> Int {
      return weight>10 ? tire1(weight) : tire2(weight)
  }
return ...
}
对于买家购买的商品,所付的钱 = 邮费 + 单价 * 体重/钱
而邮费的计算是根据体重,有不同的标准
标准1:小于20,邮费 =  体重
标准2:大于20,邮费 =  体重 * 2

func postage1(weight: Int) -> Int {
    return weight
}

func postage2(weight: Int) -> Int {
    return weight * 2
}

func choosePostage(weight: Int) -> (Int) -> Int {
    return weight < 20 ?postage1 :postage2
}

func calculateGoodPrice(weight: Int, price: Int) -> Int {
    let postage = choosePostage(weight)

    return postage(weight) + weight * price
}

calculateGoodPrice(30, price: 10)

 

 

函数嵌套

func postage1(weight: Int) -> Int {
    return weight
}

func postage2(weight: Int) -> Int {
    return weight * 2
}

func calculateGoodPrice(weight: Int, price: Int) -> Int {
    func choosePostage(weight: Int) -> (Int) -> Int {
        return weight < 20 ?postage1 :postage2
    }

    let postage = choosePostage(weight)

    return postage(weight) + weight * price
}

calculateGoodPrice(30, price: 10)

2.闭包
闭包和函数本质上是平等的,都属于引用类型.
学过OC的朋友,就足以把闭包当做block来掌握.
闭包的主导语法

let hello = {(name: String, greeting: String) -> String in
    // 函数体
    return "\(name): \(greeting)"
}

一对大括号,参数列表,再次回到类型,关键字in,加上函数体

末尾闭包:若函数最终1个参数是闭包,则闭包能够写在小括号()前面,举个例子

let showView = UIView(frame: CGRect(x: 0, y: 0, width: 200, height: 200))
let rectangle = UIView(frame: CGRect(x: 0, y: 0, width: 50, height: 50))

showView.addSubview(rectangle)
rectangle.center = showView.center
rectangle.backgroundColor = UIColor.redColor()

UIView.animateWithDuration(2.0) { 
    rectangle.backgroundColor = UIColor.blueColor()
    rectangle.frame = showView.frame
}

内容捕获:在闭包内,可以赢获得闭包外的变量(然则得注意内部存款和储蓄器难题,还有待研讨)

为我们介绍用typealias,为闭包重新定义名字

typealias SayHello = (name: String, greeting: String) -> Void

let sayHello: SayHello? = {name, greeting in
    print("\(name): \(greeting)")
}

sayHello!(name: "jj", greeting: "Hi")


let hello = {(name: String, greeting: String) -> String in
    // 函数体
    return "\(name): \(greeting)"
}

swift中没有main函数
@UIApplicationMain:表示程序入口

大家神速去试试吧!

刘雨波Demo地址:
Play-with-Swift-2

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有