'function swift_swift-functionkit - CSDN
  • Object-C swift 4.0 _cmd #function __FILE__ #file __LINE__ #line __COLUMN__  #column
    Object-C
    swift 4.0

    _cmd

    #function

    __FILE__

    #file

    __LINE__


    #line


    __COLUMN__ 


    #column


    展开全文
  • Swift-函数(Function)

    2015-05-27 16:48:54
    // main.swift // FunctionsDemo // // Created by 程磊 on 15/5/23. // Copyright (c) 2015年 chenglei. All rights reserved. // import Foundation //1.函数的定义与调用 //以 func 作为前缀,返回箭头 -> 表示...
    <pre name="code" class="objc">//
    //  main.swift
    //  FunctionsDemo
    //
    //  Created by 程磊 on 15/5/23.
    //  Copyright (c) 2015年 chenglei. All rights reserved.
    //
    
    import Foundation
    
    //1.函数的定义与调用
    //以 func 作为前缀,返回箭头 -> 表示函数的返回类型
    func sayHello(name:String) -> String {
        let greeting = "Hello" + name;
        return greeting;
    }
    
    println(sayHello("bielian"))
    
    //1.1函数的参数与返回值
    func minusResult(start: Int, end: Int) -> Int {
        return end - start;
    }
    
    println(minusResult(1,10));
    
    //1.2无参函数
    func sayHelloWorld() -> String {
        return "Hello World"
    }
    
    //1.3无返回值函数
    /*
        严格上来说,虽然没有定义返回值,sayGoodBye函数依然返回了值。
        没有定义返回类型的函数会返回特殊的值,叫Void。它其实是一个空的元组(tuple),没有任何元素,可以写成()
    */
    func sayGoodBye(name: String){
        println("GoodBye \(name)");
    }
    
    println(sayGoodBye("bielian"))
    
    //1.4多重返回值函数
    func count(string: String) -> (vs: Int, cs: Int, os:Int) {//返回一个元组
        var vowels = 0, consonants = 0, others = 0
        for character in string {
            switch String(character).lowercaseString {
                case "a","e","i","o","u":
                    ++vowels;
                case "b","c","d","f","g","h":
                    ++consonants;
                default:
                    ++others;
            }
        }
        return (vowels, consonants, others);
    }
    
    let total = count("Hello!")
    println("\(total.vs) vowels, and\(total.cs) consonants and\(total.os)others")
    
    //2  函数参数名
    //2.1 外部参数名
    
    //Demo:把两个字符串联在一起,演示使用外部参数的好处
    /*
        不使用外部参数
    */
    //func join(s1: String, s2: String, joiner: String) -> String {
    //    return s1 + joiner + s2;
    //}
    //println(join("Hello","World",","))
    
    //使用外部参数
    func join(string s1:String, toSting s2: String, withJoiner joiner: String) -> String {
        return (s1 + joiner + s2);
    }
    println(join(string: "hello", toSting: "world", withJoiner: ","));
    
    //2.2 简写外部参数名
    //如果你需要提供外部参数名,但是局部参数名已经定义好了,那么你不需要写两次这些参数名。相反,只写一次参数名,并用井号(#)作为前缀就可以了。这告诉Swift使用参数名作为局部和外部参数名。
    func containsCharacter(#string: String, #charactertoFind: Character) -> Bool {
        for character in string {
            if character == charactertoFind {
                return true
            }
        }
        return false
    }
    
    //这样定义参数名,使得函数体更为可读,清晰,同时也可以以一个不含糊的方式被调用
    let containsCon = containsCharacter(string: "qwertyuiop", charactertoFind: "y")
    println(containsCon)
    
    //2.3 默认参数值
    //你可以在函数体中为每个参数定义默认值。当默认值被定以后,调用这个函数时可以略去这个参数
    func join2(string s1:String, toString s2:String, withJoiner joiner:String = ",") ->String {
        return s1 + joiner + s2
    }
    
    let str1 = join2(string: "hello", toString: "world", withJoiner: "-");//指定第三个参数
    println(str1);
    
    let str2 = join2(string: "hello", toString: "world")
    println(str2)
    
    //2.4 默认参数的外部参数名
    func join2(s1: String, s2: String, joiner: String = " ") -> String {
        return s1 + s2 + joiner
    }
    let str3 = join2("hello", "world", joiner: "=")
    
    
    //3.可变参数
    //传入可变参数的值在函数体内当做这个类型的一个数组。例如,一个叫做numbers 的 Double... 型可变参数,在函数体内可以做一个叫numbers的Double[]型的数组常量。
    //一个函数最多能有一个可变参数
    //可变参数必须放在参数表中最后的位置
    func aritheticMean(numbers: Double...) -> Double {
        var total: Double = 0;
        for number in numbers {
            total += number
        }
        return total / Double(numbers.count)
    }
    println(aritheticMean(1.1, 1.3, 1.5))
    println(aritheticMean(0.3, 0.5, 0.9))
    
    //4 常量参数与变量参数
    //函数参数默认是常量。但有时候,如果函数中传入的参数可以修改的话将很有用。你可以通过指定一个或者多个参数为变量参数,从而避免自己在函数中定义新的变量,变量参数不是常量,你可以在函数中把它当做新的可以修改的副本来使用。
    //通常在参数名前加关键字 var 来定义变量参数
    func alignRight(var string: String, countNum: Int, pad:Character) -> String {//想要指定变量参数在其参数名前面加关键字var
        let amountToPad = countNum - count(string)
        for _ in 1...amountToPad {
            string = String(pad) + string
        }
        return string
    }
    
    let originalString = "Hello"
    let paddedString = alignRight(originalString, 10, "-")
    println("originalString:" + originalString)
    println("paddedString" + paddedString)
    
    //5 输入输出参数
    //变量参数,正如上面所述,仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值,并且想要这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数(In-Out Parameters).
     //定义一个输入输出参数,在参数的前面加inout关键字
    //输入输出参数不能有默认值,而且可变参数不能用inout标记,如果你用inout标记一个参数,这个参数就不能被var 或者 let标记
    func swapTwoInts(inout a: Int, inout b: Int) {
        let temp = a
        a = b
        b = temp
    }
    
    //只能传入一个变量作为输入输出参数
    var someInt = 3
    var anotherInt = 7
    
    //当传入的参数作为输入输出参数时,需要在参数的前面加&,表示这个值可以被函数修改
    swapTwoInts(&someInt, &anotherInt)
    println("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
    
    //6.函数类型
    //分三步: 1.定义函数;2.声明函数类型变量或常量;3.给函数类型变量赋值
    func addToInts(a: Int, b: Int) -> Int {
        return a + b;
    }
    
    //2.声明函数类型变量,如下声明了一个叫做mathFunction的变量,类型是'一个有两个Int型的参数并返回一个Int型的值的函数',这里定义的参数类型以及返回值类型与上面定义的函数参数类型以及返回值类型都是一一对应的
    var mathFunction: (Int, Int) -> Int
    
    //3.给函数类型变量赋值
    mathFunction = addToInts;
    
    //可以讲上述步骤合并
    //(1)
    var mathFunction2: (Int, Int) -> Int = addToInts;
    //(2)
    var mathFunction3 = addToInts
    
    //4.使用
    println("Result: \(mathFunction(2,3)) ")
    println("Result2: \(mathFunction2(2,3)) ")
    println("Result3: \(mathFunction3(2,3)) ")
    
    
    
    //Swift中调用C或者OC函数,必须要建立一个.h作为桥梁,其命名格式为"项目名字-Bridging-Header.h",在文件中引入相对应的文件或者方法,如果是C函数,则直接将方法名引入即可,如果是OC函数,则直接import导入头文件即可
    //Swift中调用C函数
    desc1()
    
    //Swift中调用OC函数
    var funcClass = FuncBlock()  //拿到OC类对象
    funcClass.desc2()
    
    
    //6.1函数类型作为参数类型
    func printMathResult(mathFun: (Int, Int) -> Int, a: Int, b: Int) {
        println("Result4: \(mathFun(a,b))")
    }
    
    printMathResult(addToInts, 3, 4)
    
    
    //6.2 函数类型作为返回类型
    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 moveNearTozero:(Int) -> Int = chooseStepFunction(currentValue > 0)//原型
    let moveNearTozero = chooseStepFunction(currentValue > 0)
    println("moveNearTozero = \(moveNearTozero)")//并没有调用其中的函数
    println("Result5 = \(moveNearTozero(6))")
    
    //嵌套函数
    func chooseStepFunction2(backwards: Bool) -> (Int) -> Int {
        func stepForward2(input: Int) -> Int {
            return input + 1
        }
        
        func stepBackward2(input: Int) -> Int {
            return input - 1
        }
        return backwards ? stepBackward2 : stepForward2 //返回函数类型
    }
    var currentValue2 = -4
    let moveNearTozero2 = chooseStepFunction2(currentValue2 > 0)
    println("Result6 = \(moveNearTozero2(10))")
    
    
    //8.闭包
    /*
        表达式语法一般形式如下:
        {(parameters) -> returnType in 
            statements
        }
    */
    //8.1闭包表达式
    
    //不使用闭包
    let names = ["Bielian","Harry","Howard","James","Young"]
    func backwards(s1: String, s2: String) -> Bool {
        return s1 > s2
    }
    var reversed = names.sorted(backwards)
    println("reversed = \(reversed)")
    
    //使用闭包
    //闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成,闭包函数即将开始
    reversed = names.sorted({(s1: String,s2: String) -> Bool in
        return s1 > s2
    })
    println("reversed = \(reversed)")
    
    //根据上下文推断类型
    reversed = names.sorted({(s1, s2) in return s1 > s2})
    println("reversed = \(reversed)")
    
    //8.2单表达式闭包隐式返回
    //如果闭包体中只有一个表达式,那么return关键字可以省略
    reversed = names.sorted({(s1, s2) in s1 > s2})
    println("reversed = \(reversed)")
    
    //8.3参数名称缩写
    //Swift自动为内联函数提供了函数名称缩写功能,可以直接通过$0、$1、$2来顺序调用闭包的函数
    //如果闭包函数表达式中使用参数名称缩写,可以在闭包参数列表中省略对其的定义,in关键字也可以省略
    reversed = names.sorted({$0 > $1})
    println("reversed = \(reversed)")
    
    //8.4运算符函数
    //Swift的String类型定义了关于大于号(>)的字符串实现
    reversed = names.sorted(>)
    println("reversed = \(reversed)")
    
    //8.5尾随闭包
    //如果需要将一个很长的闭包表达式(以至于不能在一行中进行书写时)作为最后一个参数传递给函数,可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式,函数支持将其作为最后一个参数调用
    reversed = names.sorted(){
        $0 > $1
    }
    println("reversed = \(reversed)")
    
    
    //8.6捕获值
    func makeIncrementor(forIncrement amount: Int) -> ()->Int {
        var runningTotal = 0
        
        //incrementor函数并没有获取任何参数,但是在函数体内访问了runningTotal和amount变量。这是因为其通过捕获在包含他的函数体内已经存在的runningTotal和amount变量而实现
        func incrementor() -> Int {
            runningTotal += amount
            return runningTotal
        }
        return incrementor
    }
    let incrementByTen = makeIncrementor(forIncrement: 10)
    //因为每次调用该函数的时候都会修改runningTotal的值,incrementor捕获了当前runningTotal变量的引用,而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeIncrementor结束时候并不会消失,也保证了当下一次执行incrementor函数时,runningTotal可以继续增加
    println(incrementByTen())   //10
    println(incrementByTen())   //20
    println(incrementByTen())   //30
    
    let incrementByOne = makeIncrementor(forIncrement: 1)
    println(incrementByOne())
    
    //8.7闭包是引用类型
    //上面的例子中,incrementByOne和ByTen是常量,但是这些常量指向的闭包仍然可以增加其捕获的变量值。这是因为函数和闭包都是引用类型
    
    //如果将闭包赋值给了两个不同的常量/变量,两个值实际上指向的还是同一个闭包,所以仍然会改变其捕获的变量值
    let alsoIncrementByTen = incrementByTen
    println(alsoIncrementByTen())   //40


    
    
    展开全文
  • Swift中的Function

    2015-12-15 17:34:49
    概述:在刚学习Swift的时候,我都是盲目的找资料,这里找一点那里找一点,没有统一的学习资料。正好这段时间公司没有什么事情做,领导又让我学习一下Swift编程,索性我就跟着Apple官方的推荐的《The Swift ...

    
    

    概述:在刚学习Swift的时候,我都是盲目的找资料,这里找一点那里找一点,没有统一的学习资料。正好这段时间公司没有什么事情做,领导又让我学习一下Swift编程,索性我就跟着Apple官方的推荐的《The Swift Programming Language》书籍来系统的学习一下Swift。也建议想学习Swift的同学认真跟着这本书去学习,因为这本书真的很不错!      我这里自己的总结都是在本书中学到的!

    1、Defining and Calling Functions   定义和调用函数

    func sayHello01(personName:String)->String{
       let greenting = "hello \(personName)"
       return greeting ;
    }
    print(sayHello01("张三"))
    
    我之前学习过java、javascript,这和swift声明函数的方式有点相似,有时候容易就写成Javascript的函数声明了,不过多敲几遍就记住了,也不容易混淆。


    </pre><p>2、Function whitout Parameters   没有参数的函数</p><pre name="code" class="objc">func sayHello02()->String{
    <p class="p1"><span class="s1">   return</span><span class="s2"> </span><span class="s3">"Hello World!"</span></p>}

    3、Function with Multiple Parameters  含有多个参数的函数

    func sayhello03(personName:String,alreadyGreeted:Bool)->String{
        if alreadyGreeted{
           return "haved say Hello!"
        }else{
           return "Hello \(personName)!"
        }
    }
    sayhello02("张三", alreadyGreeted: false)
    注意:在调用一个多参数的函数时,除了第一个不需要写形参外,后面的参数必须要写形参,否则,编译会报错!但是也有方法可以不需要写形参,继续往下看。


    4、Function whitout Return Values 没有返回值的函数

    func sayHello04(personName:String){
        print("Hello \(personName)!")
    }
    sayHello04("Jan")
    


    5、Function with Multiple Return Values   多个返回值的函数

    func minMax(array:[Int])->(min:Int,max:Int){
        var min = 0 ;
        var max = 0 ;
        for number in array{
            if number<min{
                min = number
            }
            if number > max {
                max = number
            }
        }
        return (min ,max)
    }
    var result = minMax([10,2,13,29,99,-11])
    print("The min number is \(result.min)")
    print("The max number is \(result.max)")
    
    注意:这里涉及到元组的内容,如果对元组不熟悉的同学,可以先看看元组的定义和使用方法。

    6、Optional Tuple Return Type  可选元组返回类型

    func minMax1(array:[Int])->(min:Int,max:Int)?{
        var min = 0 ;
        var max = 0 ;
        for number in array{
            if number<min{
                min = number
            }
            if number > max {
                max = number
            }
        }
        return (min ,max)
    }
    说明:可选元组返回类型指的是可以返回元组,也可以返回nil。


    7、Specifying External Parameter Names   指定外部名称

    func sayHello05(to person:String, and anOtherPerson:String){
        print("Hello \(person) and \(anOtherPerson)")
    }
    sayHello05(to: "张三", and: "李四 !")

    说明:这样的函数写法我们可以理解为语义化,在官方的解释是:The use of external parameter names can allow a function to be called  in an expressive,sentence-like manner,while still providing a function body that is readable and clear in intent.     意思是说外部参数使得函数表达的意思更丰富,使得函数体看起来就知道该函数的意图。

    8、Omitting external Parameter Names    忽略外部参数的名称

    func sayHello06(personName:String,_ anOtherPersonName:String){
      print("Hello \(personName) and \(anOtherPersonName)")
    }
    sayHello06("张三", "李四")
    说明:我们可以使用下划线‘_’来忽略外部参数的名称,在调用的时候可以不用写外部参数的名称,正如上3所述,我们可以是改方法来声明函数,在调用的时候就不需要写形参的名称。


    9、Default Parameter Values 默认的参数值

    func sayHello07(personName:String="张三"){
        print("Hello \(personName)")
    }
    sayHello07()


    10、Variadic Parameters   可变的参数(可能有多个参数)

    func sayHello07(personName:String...){
        var allName:String = "" ;
        for name in personName{
           allName+=name
        }
        print("Hello \(allName)")
    }
    sayHello07("A","B")
    
    说明:这里使用的‘...’来表示同一类型的参数可能有多个。





     





















    
    

    展开全文
  • function closure 参数之间以,相隔 Y Y 有内参与名外参名 Y Y 自动定义外参名 Y N 参数支持var, inout关键字 Y Y 参数支持可变个数 Y Y 设置参数默认值 Y N capture from enclosing scope Y Y ...
    function closure
    参数之间以,相隔 Y Y
    有内参与名外参名 Y Y
    自动定义外参名 Y N
    参数支持var, inout关键字 Y Y
    参数支持可变个数 Y Y
    设置参数默认值 Y N
    capture from enclosing scope Y Y
    泛型 Y N
    trailing closure语法 N Y
    就地定义和赋值 N Y
    根据内容推导参数和返回值 N Y
    速度参数,如$0 N Y
    对于只条一句的情况,可以推导出return N Y
    展开全文
  • Laravel邮件错误

    2019-11-19 10:48:16
    <p>I followed exception stack trace, and found that in <code>Swift_SmtpTransport::__construct()</code> parameters are sent right, but from there <code>Swift_EsmtpTransport::__construct()</code> is ...
  • Swift __FILE__ #file 打印当前文件路径,c字符串 __LINE__ #line 打印当前行号,整数 __FUNCTION__ #function 打印当前函数或方法 转载于:...
  • Swift_函数(Function)

    2015-11-18 21:19:45
    函数(Function) Swift中的函数,就相当于OC中的方法。但是语法上变化的地方很多,并且还增加了OC中没有的功能,下面详细介绍: 函数类型 无参数、无返回值 // func : 函数标志 // function1 : 函数名 //...
  • Swift5 5.函数Function

    2020-07-12 20:12:32
    目录FunctionFunction具有多个返回值的函数返回Optional内部外部名称: Argument Labels and Parameter Names默认参数值可变参数In-Out 参数Function Types使用Function TypesFunction Types作为另一个函数的参数...
  • Swift Function & Closure

    2015-05-14 16:09:48
    Functions Functions are self-contained chunks of code that perform a specific task. You give a function a name that identifies what it does, and this name is used to “call” the function to perform
  • The following code compiles in Swift 1.2: 以下代码在Swift 1.2中进行编译: class myClass { static func myM
  • 因为xcode9同时支持Swift4和Swift3.2所以在升级Swift4的时候心没有那么的痛,在转换成Swift4时错误集中在添加@objc上,如果项目是OC和Swift共存的项目,那么添加@objc会让你加到怀疑人生。 @objc 1、在Swift4中,OC...
  • 我们首先通过下面这个例子回顾一下已经学习过的 SwiftUI 中的 Swift 5.1 新特性:some SwiftUI 和 Swift 5.1 新特性(1) 不透明返回类型 Opaque Result Type,以及@State 和 @Binding背后的 @propertyDelegate ...
  • Swift 5 函数 function

    2019-09-02 16:17:53
    函数 隐式返回: 函数体是单一表达式,函数可以隐式返回这个表达式 func sumfunc(v1: Int, v2: Int) -> Int { v1 + v2 } ...返回元组:实现多返回值 ...func calculate(v1: Int, v2: Int) ->...
  • 用Xcode8打开自己的Swift2.3的项目,选择Edit->Convert->To Current Swift Syntax… 让Xcode帮我们把Swift2.3的代码转换为Swift3.0。 手动调出Xcode自动转换Swift2.3 到 Swift3.0弹出语言版本选择界面,选择Covert ...
  • 今天给别人讲个Observable的实现和使用场景,结合Observable-Swift github: https://github.com/slazyk/Observable-Swift 讲了半天貌似还没有特别明白,故写了个简易的实现,讲述了下Observable属性监控机制。...
  • Swift的统一函数语法足够灵活,可以表达从没有参数名称的简单C风格函数到具有每个参数的名称和参数标签的复杂Objective-C风格方法。参数可以提供默认值以简化函数调用,并且可以作为输入输出参数传递,这些参数在...
  • Swift关键字总结下篇

    2019-06-03 16:53:35
    Swift 中有多少关键字? 在Swift官方文档的词汇结构中, 有非常多的关键字, 它们被用于声明中、语句中、表达式中、类中、模式中, 还有以数字符号#开头的关键字, 以及特定上下文环境使用的关键字。本文中涉及的代码...
  • swift已经慢慢变得越来越让人喜欢了。所以,我们团队开始尝试探索把我们庞大的项目实现oc和swift的混编。至于为什么不直接重构,那是因为实在是时间和事实不允许,毕竟我们的APP已经是好几年的庞然大物了。  ...
  •   一直以来都是用Object-C语言来进行项目的开发,中间学过好几次swift都因为没有在项目中实践,慢慢的给忘了。最近工作稍微闲下来了,决定使用swift。刚开始使用就发现JKRouter在swift语言环境下有一些地方需要...
  • Swift 中 callback 调用

    2016-03-24 16:13:56
    Swift closures and functions are decidedly not C functions. They exist in a weird halfway state between C++ members and Objective-C blocks, so you'll have to move any callbacks into an Objective-C fil
1 2 3 4 5 ... 20
收藏数 9,304
精华内容 3,721
关键字:

'function swift