swift——函数

函数是用来完成特定任务的独立的代码块。给一个函数起一个合适的名字,用来标识函数做什么,并且当函数需要执行的时候,这个名字会被用于“调用”函数。

Swift 统一的函数语法足够灵活,可以用来表示任何函数,包括从最简单的没有参数名字的 C 风格函数,到复杂的带局部和外部参数名的 Objective-C 风格函数。参数可以提供默认值,以简化函数调用。参数也可以既当做传入参数,也当做传出参数,也就是说,一旦函数执行结束,传入的参数值可以被修改。

在 Swift 中,每个函数都有一种类型,包括函数的参数值类型和返回值类型。可以把函数类型当做任何其他普通变量类型一样处理,这样就可以更简单地把函数当做别的函数的参数,也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中,这样可以在嵌套函数范围内实现功能封装。

函数的定义与调用(Defining and Calling Functions)

当定义一个函数时,可以定义一个或多个有名字和类型的值,作为函数的输入(称为参数,parameters),也可以定义某种类型的值作为函数执行结束的输出(称为返回类型,return type)。

每个函数有个函数名,用来描述函数执行的任务。要使用一个函数时,用函数名“调用”,并传给它匹配的输入值(称作实参,arguments)。一个函数的实参必须与函数参数表里参数的顺序一致。

在下面例子中的函数叫做"sayHello(_:)",之所以叫这个名字,是因为这个函数用一个人的名字当做输入,并返回给这个人的问候语。为了完成这个任务,定义一个输入参数-一个叫做 personNameString 值,和一个包含给这个人问候语的 String 类型的返回值:

func sayHello(personName: String) -> String {
    let greeting = "Hello, " + personName + "!"
    return greeting
}

所有的这些信息汇总起来成为函数的定义,并以 func 作为前缀。指定函数返回类型时,用返回箭头 ->(一个连字符后跟一个右尖括号)后跟返回类型的名称的方式来表示。

该定义描述了函数做什么,它期望接收什么和执行结束时它返回的结果是什么类型。这样的定义使得函数可以在别的地方以一种清晰的方式被调用:

print(sayHello("Anna"))
// prints "Hello, Anna!"
print(sayHello("Brian"))
// prints "Hello, Brian!"

调用 sayHello(_:) 函数时,在圆括号中传给它一个 String 类型的实参,例如 sayHello("Anna")。因为这个函数返回一个 String 类型的值,sayHello 可以被包含在 print(_:separator:terminator:) 的调用中,用来输出这个函数的返回值,正如上面所示。

sayHello(_:) 的函数体中,先定义了一个新的名为 greetingString 常量,同时赋值了给 personName 的一个简单问候消息。然后用 return 关键字把这个问候返回出去。一旦 return greeting 被调用,该函数结束它的执行并返回 greeting 的当前值。

可以用不同的输入值多次调用 sayHello(_:)。上面的例子展示的是用"Anna""Brian"调用的结果,该函数分别返回了不同的结果。

为了简化这个函数的定义,可以将问候消息的创建和返回写成一句:

func sayHelloAgain(personName: String) -> String {
    return "Hello again, " + personName + "!"
}
print(sayHelloAgain("Anna"))
// prints "Hello again, Anna!"

函数参数与返回值(Function Parameters and Return Values)

函数参数与返回值在 Swift 中极为灵活。可以定义任何类型的函数,包括从只带一个未名参数的简单函数到复杂的带有表达性参数名和不同参数选项的复杂函数。

无参函数(Functions Without Parameters)

函数可以没有参数。下面这个函数就是一个无参函数,当被调用时,它返回固定的 String 消息:

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// prints "hello, world"

尽管这个函数没有参数,但是定义中在函数名后还是需要一对圆括号。当被调用时,也需要在函数名后写一对圆括号。

多参数函数 (Functions With Multiple Parameters)

函数可以有多种输入参数,这些参数被包含在函数的括号之中,以逗号分隔。

这个函数取得一个人的名字和是否被招呼作为输入,并对那个人返回适当的问候语:

func sayHello(personName: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return sayHelloAgain(personName)
    } else {
        return sayHello(personName)
    }
}
print(sayHello("Tim", alreadyGreeted: true))
// prints "Hello again, Tim!"

通过在括号内传递一个String参数值和一个标识为alreadyGreetedBool值,使用逗号分隔来调用sayHello(_:alreadyGreeted:)函数。

当调用超过一个参数的函数时,第一个参数后的参数根据其对应的参数名称标记。

无返回值函数(Functions Without Return Values)

函数可以没有返回值。下面是 sayHello(_:) 函数的另一个版本,叫 sayGoodbye(_:),这个函数直接输出 String 值,而不是返回它:

func sayGoodbye(personName: String) {
    print("Goodbye, \(personName)!")
}
sayGoodbye("Dave")
// prints "Goodbye, Dave!"

因为这个函数不需要返回值,所以这个函数的定义中没有返回箭头(->)和返回类型。

func sayGoodbye(personName: String) -> Void {
    print("Goodbye, \(personName)!")
}
func sayGoodbye(personName: String) () {
    print("Goodbye, \(personName)!")
}

注意
严格上来说,虽然没有返回值被定义,sayGoodbye(_:) 函数依然返回了值。没有定义返回类型的函数会返回特殊的值,叫 Void。它其实是一个空的元组(tuple),没有任何元素,可以写成()

被调用时,一个函数的返回值可以被忽略:

func printAndCount(stringToPrint: String) -> Int {
    print(stringToPrint)
    return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint: String) {
    printAndCount(stringToPrint)
}
printAndCount("hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting("hello, world")
// prints "hello, world" but does not return a value

第一个函数 printAndCount(_:),输出一个字符串并返回 Int 类型的字符数。第二个函数 printWithoutCounting调用了第一个函数,但是忽略了它的返回值。当第二个函数被调用时,消息依然会由第一个函数输出,但是返回值不会被用到。

注意
返回值可以被忽略,但定义了有返回值的函数必须返回一个值,如果在函数定义底部没有返回任何值,将导致编译错误(compile-time error)。

多重返回值函数(Functions with Multiple Return Values)

可以用元组(tuple)类型让多个值作为一个复合值从函数中返回。

下面的这个例子中,定义了一个名为minMax(_:)的函数,作用是在一个Int数组中找出最小值与最大值。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

minMax(_:)函数返回一个包含两个Int值的元组,这些值被标记为minmax,以便查询函数的返回值时可以通过名字访问它们。

minMax(_:)的函数体中,在开始的时候设置两个工作变量currentMincurrentMax的值为数组中的第一个数。然后函数会遍历数组中剩余的值并检查该值是否比currentMincurrentMax更小或更大。最后数组中的最小值与最大值作为一个包含两个Int值的元组返回。

因为元组的成员值已被命名,因此可以通过点语法来检索找到的最小值与最大值:

let bounds = minMax([8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
// prints "min is -6 and max is 109"

需要注意的是,元组的成员不需要在元组从函数中返回时命名,因为它们的名字已经在函数返回类型中指定了。

可选元组返回类型(Optional Tuple Return Types)

如果函数返回的元组类型有可能整个元组都“没有值”,可以使用可选的(Optional) 元组返回类型反映整个元组可以是nil的事实。可以通过在元组类型的右括号后放置一个问号来定义一个可选元组,例如(Int, Int)?(String, Int, Bool)?

注意
可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的.可选的元组类型,整个元组是可选的,而不只是元组中的每个元素值。

前面的minMax(_:)函数返回了一个包含两个Int值的元组。但是函数不会对传入的数组执行任何安全检查,如果array参数是一个空数组,如上定义的minMax(_:)在试图访问array[0]时会触发一个运行时错误。

为了安全地处理这个“空数组”问题,将minMax(_:)函数改写为使用可选元组返回类型,并且当数组为空时返回nil

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty {
        return nil
    }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

可以使用可选绑定来检查minMax(_:)函数返回的是一个实际的元组值还是nil

if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
// prints "min is -6 and max is 109"

函数参数名称(Function Parameter Names)

函数参数都有一个外部参数名(external parameter name)和一个局部参数名(local parameter name)。外部参数名用于在函数调用时标注传递给函数的参数,局部参数名在函数的实现内部使用。

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // function body goes here
    // firstParameterName and secondParameterName refer to
    // the argument values for the first and second parameters
}
someFunction(1, secondParameterName: 2)

一般情况下,第一个参数省略其外部参数名,第二个以及随后的参数使用其局部参数名作为外部参数名。所有参数必须有独一无二的局部参数名。尽管多个参数可以有相同的外部参数名,但不同的外部参数名能让代码更有可读性。

指定外部参数名(Specifying External Parameter Names)

可以在局部参数名前指定外部参数名,中间以空格分隔:

func someFunction(externalParameterName localParameterName: Int) {
    // function body goes here, and can use localParameterName
    // to refer to the argument value for that parameter
}

注意
如果提供了外部参数名,那么函数在被调用时,必须使用外部参数名。

这个版本的sayHello(_:)函数,接收两个人的名字,会同时返回对他俩的问候:

func sayHello(to person: String, and anotherPerson: String) -> String {
    return "Hello \(person) and \(anotherPerson)!"
}
print(sayHello(to: "Bill", and: "Ted"))
// prints "Hello Bill and Ted!"

为每个参数指定外部参数名后,在调用sayHello(to:and:)函数时两个外部参数名都必须写出来。

使用外部函数名可以使函数以一种更富有表达性的类似句子的方式调用,并使函数体意图清晰,更具可读性。

忽略外部参数名(Omitting External Parameter Names)

如果不想为第二个及后续的参数设置外部参数名,用一个下划线(_)代替一个明确的参数名。

func someFunction(firstParameterName: Int, _ secondParameterName: Int) {
    // function body goes here
    // firstParameterName and secondParameterName refer to
    // the argument values for the first and second parameters
}
someFunction(1, 2)

注意
因为第一个参数默认忽略其外部参数名称,显式地写下划线是多余的。

默认参数值(Default Parameter Values)

可以在函数体中为每个参数定义默认值(Deafult Values)。当默认值被定义后,调用这个函数时可以忽略这个参数。

func someFunction(parameterWithDefault: Int = 12) -> Int {
    // function body goes here
    // if no arguments are passed to the function call,
    // value of parameterWithDefault is 12
    return parameterWithDefault
}
someFunction(6) // parameterWithDefault is 6
someFunction() // parameterWithDefault is 12

注意
将带有默认值的参数放在函数参数列表的最后。这样可以保证在函数调用时,非默认参数的顺序是一致的,同时使得相同的函数在不同情况下调用时显得更为清晰。

可变参数(Variadic Parameters)

一个可变参数(variadic parameter)可以接受零个或多个值。函数调用时,可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入(...)的方式来定义可变参数。

可变参数的传入值在函数体中变为此类型的一个数组。例如,一个叫做 numbersDouble... 型可变参数,在函数体内可以当做一个叫 numbers[Double] 型的数组常量。

下面的这个函数用来计算一组任意长度数字的算术平均数(arithmetic mean)

func arithmeticMean(numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

注意
一个函数最多只能有一个可变参数。

如果函数有一个或多个带默认值的参数,而且还有一个可变参数,那么把可变参数放在参数表的最后。

常量参数和变量参数(Constant and Variable Parameters)

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着不能错误地更改参数值。

但是,有时候,如果函数中有传入参数的变量值副本将是很有用的。可以通过指定一个或多个参数为变量参数,从而避免自己在函数中定义新的变量。变量参数不是常量,可以在函数中把它当做新的可修改副本来使用。

通过在参数名前加关键字 var 来定义变量参数:

func alignRight(var string: String, totalLength: Int, pad: Character) -> String {
    let amountToPad = totalLength - string.characters.count
    if amountToPad < 1 {
        return string
    }
    let padString = String(pad)
    for _ in 1...amountToPad {
        string = padString + string
    }
    return string
}
let originalString = "hello"
let paddedString = alignRight(originalString, totalLength: 10, pad: "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"

这个例子中定义了一个叫做 alignRight(_:totalLength:pad:) 的新函数,用来将输入的字符串对齐到更长的输出字符串的右边缘。左侧空余的地方用指定的填充字符填充。这个例子中,字符串"hello"被转换成了"-----hello"

alignRight(_:totalLength:pad:) 函数将输入参数 string 定义为变量参数。这意味着 string 现在可以作为一个局部变量,被传入的字符串值初始化,并且可以在函数体中进行操作。

函数首先计算出有多少字符需要被添加到string的左边,从而将其在整个字符串中右对齐。这个值存储在一个称为amountToPad的本地常量。如果不需要填充(也就是说,如果amountToPad小于1),该函数简单地返回没有任何填充的输入值string

否则,该函数用pad字符创建一个叫做padString的临时String常量,并将amountToPadpadString添加到现有字符串的左边。(一个String值不能被添加到一个Character值上,所以padString常量用于确保+操作符两侧都是String值)。

注意
对变量参数所进行的修改在函数调用结束后便消失了,并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。

输入输出参数(In-Out Parameters)

变量参数,正如上面所述,仅仅能在函数体内被更改。如果想要一个函数可以修改参数的值,并且想要在这些修改在函数调用结束后仍然存在,那么就应该把这个参数定义为输入输出参数(In-Out Parameters)。

定义一个输入输出参数时,在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值,这个值被函数修改,然后被传出函数,替换原来的值。

只能传递变量给输入输出参数。不能传入常量或者字面量(literal value),因为这些量是不能被修改的。当传入的参数作为输入输出参数时,需要在参数名前加&符,表示这个值可以被函数修改。

注意
输入输出参数不能有默认值,而且可变参数不能用 inout 标记。如果用 inout 标记一个参数,这个参数不能被 var 或者 let 标记。

下面是例子,swapTwoInts(_:_:) 函数,有两个分别叫做 ab 的输入输出参数:

func swapTwoInts(inout a: Int, inout _ b: Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

这个 swapTwoInts(_:_:) 函数简单地交换 ab 的值。该函数先将 a 的值存到一个临时常量 temporaryA 中,然后将 b 的值赋给 a,最后将 temporaryA 赋值给 b

可以用两个 Int 型的变量来调用 swapTwoInts(_:_:)。需要注意的是,someIntanotherInt 在传入 swapTwoInts(_:_:) 函数前,都加了 & 的前缀:

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3"

从上面这个例子中,我们可以看到 someIntanotherInt 的原始值在 swapTwoInts(_:_:) 函数中被修改,尽管它们的定义在函数体外。

注意
输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值,但仍然修改了 someIntanotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。

函数类型(Function Types)

每个函数都有种特定的函数类型,由函数的参数类型和返回类型组成。

例如:

func addTwoInts(a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(a: Int, _ b: Int) -> Int {
    return a * b
}

这个例子中定义了两个简单的数学函数:addTwoIntsmultiplyTwoInts。这两个函数都接受两个 Int 值, 返回一个Int值。

这两个函数的类型是 (Int, Int) -> Int,可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。

下面是另一个例子,一个没有参数,也没有返回值的函数:

func printHelloWorld() {
    print("hello, world")
}

这个函数的类型是:() -> void,或者叫“没有参数,并返回 Void 类型的函数”。

使用函数类型(Using Function Types)

在 Swift 中,使用函数类型就像使用其他类型一样。例如,可以定义一个类型为函数的常量或变量,并将适当的函数赋值给它:

var mathFunction: (Int, Int) -> Int = addTwoInts

这个可以解读为:

“定义一个叫做 mathFunction 的变量,类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’,并让这个新变量指向 addTwoInts 函数”。

addTwoIntsmathFunction 有同样的类型,所以这个赋值过程在 Swift 类型检查中是允许的。

现在,可以用 mathFunction 来调用被赋值的函数了:

print("Result: \(mathFunction(2, 3))")
// prints "Result: 5"

有相同匹配类型的不同函数可以被赋值给同一个变量,就像非函数类型的变量一样:

mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// prints "Result: 6"

就像其他类型一样,当赋值一个函数给常量或变量时,可以让 Swift 来推断其函数类型:

let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int

函数类型作为参数类型(Function Types as Parameter Types)

可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样可以将函数的一部分实现留给函数的调用者来提供。

下面是另一个例子,正如上面的函数一样,同样是输出某种数学运算结果:

func printMathResult(mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"

这个例子定义了 printMathResult(_:_:_:) 函数,它有三个参数:第一个参数叫 mathFunction,类型是(Int, Int) -> Int,可以传入任何这种类型的函数;第二个和第三个参数叫 ab,它们的类型都是 Int,这两个值作为已给出的函数的输入值。

printMathResult(_:_:_:) 被调用时,它被传入 addTwoInts 函数和整数35。它用传入35调用 addTwoInts,并输出结果:8

printMathResult(_:_:_:) 函数的作用就是输出另一个适当类型的数学函数的调用结果。它不关心传入函数是如何实现的,它只关心这个传入的函数类型是正确的。这使得 printMathResult(_:_:_:) 能以一种类型安全(type-safe)的方式将一部分功能转给调用者实现。

函数类型作为返回类型(Function Types as Return Types)

可以用函数类型作为另一个函数的返回类型。需要做的是在返回箭头(->)后写一个完整的函数类型。

下面的这个例子中定义了两个简单函数,分别是 stepForwardstepBackwardstepForward 函数返回一个比输入值大一的值。stepBackward 函数返回一个比输入值小一的值。这两个函数的类型都是 (Int) -> Int

func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}

下面这个叫做 chooseStepFunction(_:) 的函数,它的返回类型是 (Int) -> Int 类型的函数。chooseStepFunction(_:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数:

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

现在可以用 chooseStepFunction(_:) 来获得两个函数其中的一个:

var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

上面这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue 的初始值是3,这意味着 currentValue > 0 是真的(true),这将使得 chooseStepFunction(_:) 返回 stepBackward(_:) 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

现在,moveNearerToZero 指向了正确的函数,它可以被用来数到0

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

嵌套函数(Nested Functions)

本文所见到的所有函数都叫全局函数(global functions),它们定义在全局域中。也可以把函数定义在别的函数体中,称作嵌套函数(nested functions)。

默认情况下,嵌套函数是对外界不可见的,但是可以被它们的外围函数(enclosing function)调用。一个外围函数也可以返回它的某一个嵌套函数,使得这个函数可以在其他域中被使用。

可以用返回嵌套函数的方式重写 chooseStepFunction(_:) 函数:

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backwards ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
  • 序言:七十年代末,一起剥皮案震惊了整个滨河市,随后出现的几起案子,更是在滨河造成了极大的恐慌,老刑警刘岩,带你破解...
    沈念sama阅读 143,736评论 1 303
  • 序言:滨河连续发生了三起死亡事件,死亡现场离奇诡异,居然都是意外死亡,警方通过查阅死者的电脑和手机,发现死者居然都...
    沈念sama阅读 61,631评论 1 258
  • 文/潘晓璐 我一进店门,熙熙楼的掌柜王于贵愁眉苦脸地迎上来,“玉大人,你说我怎么就摊上这事。” “怎么了?”我有些...
    开封第一讲书人阅读 95,145评论 0 213
  • 文/不坏的土叔 我叫张陵,是天一观的道长。 经常有香客问我,道长,这世上最难降的妖魔是什么? 我笑而不...
    开封第一讲书人阅读 41,213评论 0 181
  • 正文 为了忘掉前任,我火速办了婚礼,结果婚礼上,老公的妹妹穿的比我还像新娘。我一直安慰自己,他们只是感情好,可当我...
    茶点故事阅读 49,025评论 1 259
  • 文/花漫 我一把揭开白布。 她就那样静静地躺着,像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上,一...
    开封第一讲书人阅读 38,893评论 1 178
  • 那天,我揣着相机与录音,去河边找鬼。 笑死,一个胖子当着我的面吹牛,可吹牛的内容都是我干的。 我是一名探鬼主播,决...
    沈念sama阅读 30,497评论 2 273
  • 文/苍兰香墨 我猛地睁开眼,长吁一口气:“原来是场噩梦啊……” “哼!你这毒妇竟也来了?” 一声冷哼从身侧响起,我...
    开封第一讲书人阅读 29,240评论 0 167
  • 想象着我的养父在大火中拼命挣扎,窒息,最后皮肤化为焦炭。我心中就已经是抑制不住地欢快,这就叫做以其人之道,还治其人...
    爱写小说的胖达阅读 29,114评论 6 235
  • 序言:老挝万荣一对情侣失踪,失踪者是张志新(化名)和其女友刘颖,没想到半个月后,有当地人在树林里发现了一具尸体,经...
    沈念sama阅读 32,596评论 0 213
  • 正文 独居荒郊野岭守林人离奇死亡,尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 29,363评论 2 215
  • 正文 我和宋清朗相恋三年,在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 30,717评论 1 232
  • 白月光回国,霸总把我这个替身辞退。还一脸阴沉的警告我。[不要出现在思思面前, 不然我有一百种方法让你生不如死。]我...
    爱写小说的胖达阅读 24,279评论 0 32
  • 序言:一个原本活蹦乱跳的男人离奇死亡,死状恐怖,灵堂内的尸体忽然破棺而出,到底是诈尸还是另有隐情,我是刑警宁泽,带...
    沈念sama阅读 27,183评论 2 214
  • 正文 年R本政府宣布,位于F岛的核电站,受9级特大地震影响,放射性物质发生泄漏。R本人自食恶果不足惜,却给世界环境...
    茶点故事阅读 31,629评论 3 209
  • 文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹,春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 25,647评论 0 9
  • 文/苍兰香墨 我抬头看了看天上的太阳。三九已至,却和暖如春,着一层夹袄步出监牢的瞬间,已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,047评论 0 167
  • 我被黑心中介骗来泰国打工, 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留,地道东北人。 一个月前我还...
    沈念sama阅读 33,625评论 2 232
  • 正文 我出身青楼,却偏偏与公主长得像,于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子,可洞房花烛夜当晚...
    茶点故事阅读 33,734评论 2 236

推荐阅读更多精彩内容

  • 函数是用来完成特定任务的独立的代码块。可以给函数起一个名字,用于标识一个函数,当函数需要执行的时候,这个名字就会用...
    EndEvent阅读 727评论 1 3
  • Swift 函数用来完成特定任务的独立的代码块。Swift使用一个统一的语法来表示简单的C语言风格的函数到复杂的O...
    零度_不结冰阅读 307评论 0 0
  • 86.复合 Cases 共享相同代码块的多个switch 分支 分支可以合并, 写在分支后用逗号分开。如果任何模式...
    无沣阅读 1,261评论 1 5
  • 定义和调用函数 在下面的例子中的函数叫做greet(person :),因为这是它的作用 - 它需要一个人的名字作...
    Joker_King阅读 259评论 0 1
  • 你个小狗屎橛子 是我对她最经常的称呼 每次都会被妈妈说 可我依然不思悔改 且引以为乐 难道说是要报复 哦 不是的 ...
    一一鱼麻阅读 1,117评论 0 0