函数是一段完成特定任务的独立代码片段。

函数的组成

• 函数名：每个函数有个函数名，用来描述函数执行的任务。

func setupSubViews() {
}

• 参数：定义函数时，可以定义一个或多个限制了类型的参数，作为请求参数，多个请求参数以逗号分隔。

func getMessageByType(pageNum: Int, pageSize: Int) {
}

• 返回参数：定义函数时，可以定义一个返回值类型，用于返回函数处理结果。

func getNameContent() -> String { 
}

• 类方法标志class、static

class func logFunc1() {
}

static func logFunc2() {
}

函数的变形

按照苹果的风格，调用函数时，更像是一句话。

• 相对于OC，Swift中做了内部参数和外部参数的区分。应用好了，外部调用的时候读着像一句话，意思明确，函数内部调用时参数意思明确。
  比如为String起一个分类，定义一个截取字符串的方法，在函数内部使用location，但是在调用时，函数表现的是at

code.substring(at: idx, length: 1)

extension String {
    /// 截取特定范围的字符串 索引从 0 开始
    /// - Parameters:
    ///   - location: 开始的索引位置
    ///   - length: 截取长度
    /// - Returns: 字符串
    public func substring(at location: Int, length: Int) -> String {
        if location > self.count || (location+length > self.count) {
            assert(location < self.count && location+length <= self.count, "越界, 检查设置的范围")
        }
        var subStr: String = ""
        for idx in location..<(location+length) {
            subStr += self[self.index(self.startIndex, offsetBy: idx)].description
        }
        return subStr
    }
}

• 隐藏外部参数名
  在外部如果不需要显示参数名，可以用 _ 代替外部参数名。在调用的时候则不会显示参数名，但是内部调用的时候不受影响

getFileName(url.absoluteString)

func getFileName(_ text: String) -> String {
  let startRange: Range = text.range(of: "tmp/")!
  let startLocation: Int = text.distance(from: text.startIndex, to: startRange.upperBound)
  let subStr = text.suffix(text.count - startLocation)
  return String(subStr)
}

函数的类型

无参数无返回值。用的最多的，一般处于任务的末端，单一功能的封装。

调用即执行，目的更多是对功能的封装，提高代码可读性。

func setupSubViews() {
  view.backgroundColor = .white
}

无参数有返回值。用的不多，一般都是从已知内容中获取所需内容

比如获取当前页面输入框所输入的内容。（输入框已存在，函数获取到内容，做一番处理返回就行了）

func getInputContent() -> String? {
  if verificationMode == .mobile {
    return (codeLabel.text ?? "") + "-" + (mobileTextField.text ?? "")
  }
  return mobileTextField.text
}

有参数无返回值。用处挺多，一般是基于传入的参数，执行一系列任务。

比如调用一个有分页的接口，我需要传入一个当前的页码，函数基于页码去调用接口。

func getMessageByType(pageNum: Int, pageSize: Int) {
}

有参数有返回值。和有参数无返回值差不多，差别就在是否需要返回值。一般多用于对参数的处理，返回处理后的参数

比如对字符串进行处理

func replaceSpecialCharacters(in text: String, with replacement: String) -> String {
  do {
    let regex = try NSRegularExpression(pattern: "[^a-zA-Z0-9\u{4e00}-\u{9fa5}]", options: [])
    let range = NSRange(location: 0, length: text.utf16.count)
    return regex.stringByReplacingMatches(in: text, options: [], range: range, withTemplate: replacement)
  } catch {
    return StringSingle.res_txt_default.string
  }
}

特殊的函数

抛出错误、异常

如果一个函数可能会抛出错误，调用这个函数时需要使用try关键字，并且需要处理错误（使用do-catch语句）。

• 函数定义：

func requestData(url: String) throws -> String? {
  var code = Int.random(in: 0...3)
  switch code {
  case 0:
    let domain = "baidu"
    let userInfo = [NSLocalizedDescriptionKey: "error message"]
    let tempError = NSError(domain: domain, code: code, userInfo: userInfo)
    throw tempError
  case 1:
    return "Ok"
  case 2:
    return nil
  default:
    return nil
  }
}

• 函数调用：

let network = Network()
do {
  let resStr = try network.requestData(url: "sssss")
} catch let error{
  print(error.localizedDescription)
}

异步函数

Swift中执行耗时任务，为了不阻塞当前线程，需要开辟子线程执行任务。封装出来的函数，就是异步函数。定义一个异步函数时用到的关键字：

1. async:异步函数标志，表示此函数不会阻塞主线程。

• 函数定义：

func refreshToken(tokenType:TokenType, refreshToken: String) async -> Bool{
}

• 函数调用：

let isSuccess = await refreshToken(tokenType: tokenType, refreshToken: refresToken1)

2. async throws:

• 函数定义：

func fetchingTokenCustom(customBaseURL: String) async throws -> Data {
}

• 函数调用：

let isSuccess = await refreshToken(tokenType: tokenType, refreshToken: refresToken1)

特殊的参数

请求参数为闭包。

比如swift中数组有个.sorted(by: <(Int, Int) throws -> Bool>)方法，sorted是一个排序函数，参数是一个闭包，闭包是一个排序规则。
定义一个处理字符串的函数：

• 函数定义：

func getString(str1: String, str2: String, closure:(String, String) -> String) -> String {
  return closure(str1, str2)
}

• 函数调用1，拼接：

let appendStrClosure = { (str1: String, str2: String) in
  return str1 + str2
}
let newStr = getString(str1: "字符串1", str2: "字符串2", closure: appendStrClosure)
print("函数执行结果:", newStr)

• 函数调用2，替换：

let replaceStrClosure = { (oldString: String, replaceString: String) in
  return oldString.replacingOccurrences(of: replaceString, with: "")
}
let newStr1 = getString(str1: "这是一个测试字符串", str2: "测试", closure: replaceStrClosure)
print("函数执行结果:", newStr1)

尾随闭包。

如果闭包是函数的最后一个参数，那么可以将闭包写在（）后面。

• 函数定义：

    func getString(str1: String, str2: String, closure:(String, String) -> String) -> String {
        return closure(str1, str2)
    }

• 函数调用：

let newStr1_1 = getString(str1: "这是一个测试字符串", str2: "测试") {
  return $0.replacingOccurrences(of: $1, with: "")
}
print("尾随闭包执行结果:", newStr1_1)

• 调用结果打印

特殊的返回值

函数的返回值可以是字符串、整型、数组、字典等。类型单一，如果想要返回多个类型，可以使用元组

元组作为函数返回值

例如判断一个字符串是否是一个网址，返回一个布尔值，一个字符串

• 函数定义：

func isHTTP(text: String) -> (boolValue:Bool, result: String){
  var tuple: (Bool,String)
  if text.hasPrefix("http"){
    tuple = (true, text+"是个网址,可以直接访问")
  } else {
    tuple = (false, text+"不是一个网址")
  }
    return tuple
}

• 函数调用：

let urlArr = ["https://www.baidu.com", "goole.com"]
  urlArr.forEach { string in
  if isHTTP(text: string).boolValue {
    print(isHTTP(text: string).result)
  } else {
    print(isHTTP(text: string).result)
  }
}

• 调用结果打印