首页 > 编程语言 > 详细

Swift 属性 函数

时间:2019-04-22 14:07:18      阅读:116      评论:0      收藏:0      [点我收藏+]

如今看cocoachina上得文章越来越有质量了,果断分享一下?

原文:?http://www.cocoachina.com/newbie/basic/2014/0611/8773.html

函数


函数是运行特定任务的代码自包括块。

通过给定一个函数名称标识它是什么,并在须要的时候使用该名称来调用函数以运行任务。

?

Swift的统一的功能语法足够灵活的。可表达不论什么东西。不管是不带參数名称的简单的样式函数,还是带本地和外部參数名称的复杂的Objective-C样式方法。

參数可为简单函数调用提供默认值,而且能够被作为输入/输出參数传递,在函数运行完毕时改动传递来的变量。

?

Swift中的每一个函数都有一个类型,包括函数的參数类型和返回类型。你能够像使用Swift中其它类型一样使用该类型,这使得它很easy将函数作为參数传递给其它函数,甚至从函数中返回函数类型。函数也能够被写入其它函数中以在函数作用于中封装实用的功能。

?

定义和调用函数


当你定义一个函数时,你能够选择性地定义一个或多个名称,类型值作为函数的输入(称为形參)。或者定义一个函数结束后返回值的类型(称之为返回型)。每一个函数都有一个函数名。用来描写叙述了函数运行的任务。要使用一个函数时。可使用它的名称进行“调用”。并通过它的输入值(称为实參--argument)来匹配函数的參数类型。

一个函数的实參(arguments)必须始终和函数形參(parameter)顺序一致。

?

比如在以下的样例中被调用的函数greetingForPerson,像它描写叙述的那样 -- 它须要一个人的名字作为输入并返回一句针对那个人的问候语。为了实现该功能,你定义了一个输出參数--一个名为personName的字符串值,以及一个String返回类型,包括一个针对那个人的问候语:

  1. func?sayHello(personName:?String)?->?String?{?
  2. ????let?greeting?=?"Hello,?"?+?personName?+?"!"?
  3. ????return?greeting?
  4. }?

全部这些信息都汇总到以func关键字为前缀的函数定义中。使用箭头->来指明函数的返回类型(一个连字符后跟一个向右的箭头),后边跟着返回的类型名称。

?

该定义描写叙述了函数的作用是什么,它期望接收什么,以及完毕后返回的结果。

该定义可轻易地让你在代码中的其它地方清晰明白地调用该函数:

  1. println(sayHello("Anna"))?
  2. //?prints?"Hello,?Anna!"?
  3. println(sayHello("Brian"))?
  4. //?prints?"Hello,?Brian!"?

你能够通过给它传递一个圆括号内String实參值来调用sayHello函数,比如sayHello("Anna")。

由于该函数返回一个String值,sayHello能够被包裹在一个println函数调用中来打印字符串。看看它的返回值,如上图所看到的。

?

sayHello的函数主体首先定义了一个新的名为greeting的String常量,并将其设置加上personName组成一句简单的问候消息。

然后这个greeting以关键字return来传回到函数外部。仅仅要return greeting被调用,函数运行完毕后就会返回greeting的当前值。

?

你能够通过不同的输入值多次调用sayHello的函数。上面的样例显示了假设使用"Anna"输入值调用它会发生什么,以及以"Brian"输入值调用时会发生什么。函数为每种情况量身定制了问候语。

?

为了简化这个函数的主体,可把消息创建和return语句合并成一行:

  1. func?sayHello(personName:?String)?->?String?{?
  2. ????return?"Hello?again,?"?+?personName?+?"!"?
  3. }?
  4. println(sayHello("Anna"))?
  5. //?prints?"Hello?again,?Anna!"?

?

函数的形參和返回值


在swift中。函数的形參和返回值是很具有灵活性的。

你能够定义不论什么事情,不管是一个简单的仅有一个未命名形參的工具函数,还是那种具有丰富的參数名称和不同的形參选项的复杂函数。

?

多输入形參

函数能够有多个输入形參,把它们写到函数的括号内,并用逗号加以分隔。

以下这个函数设置了一个半开区间的開始和结束索引。用来计算在范围内有多少元素:

  1. func?halfOpenRangeLength(start:?Int,?end:?Int)?->?Int?{?
  2. ????return?end?-?start?
  3. }?
  4. println(halfOpenRangeLength(1,?10))?
  5. //?prints?"9"?

?

无形參函数

函数并没有要求一定要定义的输入形參。以下就是一个没有输入形參的函数。不论什么时候调用时它总是返回同样的String消息:

  1. func?sayHelloWorld()?->?String?{?
  2. ????return?"hello,?world"?
  3. }?
  4. println(sayHelloWorld())?
  5. //?prints?"hello,?world"?

该函数的定义还须要在函数的名称后跟一对儿圆括号,即使它不带不论什么形參。

当函数被调用时函数名称也要跟着一对儿空括号。

?

无返回值的函数

函数不须要定义一个返回类型。这里有一个版本号的sayHello函数,称为waveGoodbye。它会打印自己的String值而不是返回它:

  1. func?sayGoodbye(personName:?String)?{?
  2. ????println("Goodbye,?\(personName)!")?
  3. }?
  4. sayGoodbye("Dave")?
  5. //?prints?"Goodbye,?Dave!"?

?由于它并不须要返回一个值。该函数的定义不包括返回箭头( - >)和返回类型。

??提示:严格地说。sayGoodbye函数确实还返回一个值,即使未定义返回值。未定义返回类型的函数返回了一个Void类型的特殊值。这仅是一个空元组,这里边没有元素,能够被写成()。

当一个函数调用时它的返回值能够忽略不计:

  1. func?printAndCount(stringToPrint:?String)?->?Int?{?
  2. ????println(stringToPrint)?
  3. ????return?countElements(stringToPrint)?
  4. }?
  5. func?printWithoutCounting(stringToPrint:?String)?{?
  6. ????printAndCount(stringToPrint)?
  7. }?
  8. printAndCount("hello,?world")?
  9. //?prints?"hello,?world"?and?returns?a?value?of?12?
  10. printWithoutCounting("hello,?world")?
  11. //?prints?"hello,?world"?but?does?not?return?a?value?

?第一个函数printAndCount。打印了一个字符串。然后并以Int类型返回它的字符数。

第二个函数printWithoutCounting,调用的第一个函数。但忽略它的返回值。当第二函数被调用时。消息由第一函数打印了回来。但没有使用其返回值。

?提示:返回值能够忽略,但一个定义了返回值的函数则必须有返回值。

对于一个定义了返回类型的函数来说,假设没有返回值,那么将不同意控制流离开函数的底部。

假设试图这样做将出现一个编译时错误。

?

多返回值函数

你能够使用一个元组类型作为函数的返回类型,来返回一个由多个值组成的复合返回值。

?

以下的样例定义了一个名为count函数,用来计算字符串中基于标准美式英语的元音、辅音以及字符的数量:

  1. func?count(string:?String)?->?(vowels:?Int,?consonants:?Int,?others:?Int)?{?
  2. ????var?vowels?=?0,?consonants?=?0,?others?=?0?
  3. ????for?character?in?string?{?
  4. ????????switch?String(character).lowercaseString?{?
  5. ????????case?"a",?"e",?"i",?"o",?"u":?
  6. ????????????++vowels?
  7. ????????case?"b",?"c",?"d",?"f",?"g",?"h",?"j",?"k",?"l",?"m",?
  8. ????????"n",?"p",?"q",?"r",?"s",?"t",?"v",?"w",?"x",?"y",?"z":?
  9. ????????++consonants?
  10. ????????default:?
  11. ????????++others?
  12. ????????}?
  13. ????}?
  14. ????return?(vowels,?consonants,?others)?
  15. }?

您能够使用此计数函数来对随意字符串进行字符计数,以检索一个包括三个指定Int值的元素统计总数:

  1. let?total?=?count("some?arbitrary?string!")?
  2. println("\(total.vowels)?vowels?and?\(total.consonants)?consonants")?
  3. //?prints?"6?vowels?and?13?consonants"?

注意:这一点上元组的成员不须要被命名,元组是从函数中返回的,由于它们的名字已经被指定为函数的返回类型的一部分。

?

函数形參名


全部上面的函数都为其形參定义了形參名:

  1. func?someFunction(parameterName:?Int)?{?
  2. ????//?function?body?goes?here,?and?can?use?parameterName?
  3. ????//?to?refer?to?the?argument?value?for?that?parameter?
  4. }?

然而,这些參数名的仅能在函数本身的主体内使用。不能在调用函数时使用。这样的形參类型名称被称之为本地形參名(local parameter name),由于它们仅仅能在函数的主体中使用。

?

外部形參名

有时当你调用一个函数将每一个形參进行命名是很实用的,以表明你把每一个实參传递给函数的目的。

?

假设你希望使用你函数的人在调用函数时提供形參名称,那除了本地形參名外。你还要为每一个形參定义一个外部形參名称。你写一个外部形參名称在它所支持的本地形參名称之前,之间用一个空格来分隔:

  1. func?someFunction(externalParameterName?localParameterName:?Int)?{?
  2. ????//?function?body?goes?here,?and?can?use?localParameterName?
  3. ????//?to?refer?to?the?argument?value?for?that?parameter?
  4. }?
??提示:假设您为形參提供一个外部形參名称。那么外部形參名必须在调用时使用。

举一个样例,考虑以下的函数。通过在它们之间插入第三个"joiner"字符串来连接两个字符串:

  1. func?join(s1:?String,?s2:?String,?joiner:?String)?->?String?{?
  2. ????return?s1?+?joiner?+?s2?
  3. }?

?

当你调用这个函数,你传递给函数的三个字符串的目的就不是很清晰了:

  1. join("hello",?"world",?",?")?
  2. //?returns?"hello,?world"?

?

为了使这些字符串值的目的更为清晰,为每一个join函数形參定义外部形參名称:

  1. func?join(string?s1:?String,?toString?s2:?String,?withJoiner?joiner:?String)?
  2. ????->?String?{?
  3. ????return?s1?+?joiner?+?s2?
  4. }?

在这个版本号的join函数中,第一个形參的外部名称string。本地名称s1;第二个形參的外部名称toString。本地名称s2;第三个形參的外部名称是withJoiner,本地名称为joiner。

?

如今,您能够使用这些外部形參名称清晰明白地调用该函数:

  1. join(string:?"hello",?toString:?"world",?withJoiner:?",?")?
  2. //?returns?"hello,?world"?

?使用外部參数名称使join函数的第二个版本号功能以更富有表现力,用户习惯的sentence-like方式调用函数,同一时候还提供了一个可读的、意图明白的函数体。

??注意:在别人第一次阅读你的代码不知道你函数形參目的时候,就要考虑到使用外部形參名称了。

在调用函数的时候,假设每一个形參的目的清晰明白的话。那你就无需指定外部形參名。

?

外部參数名称速记

假设你想为一个函数提供一个外部形參名,然而本地形參名已经使用了一个合适的名称了,那你就不须要两次书写该形參的名称。相反,你能够写一次名字,并用一个hash符号(#)作为名称的前缀。

这就告诉Swift使用名称同样的本地行參名称和外部形參名称。

?

这个样例定义了一个名为containsCharacter的函数,通过在本地形參名前加入hash符号(#)来定义外部形參名称。

  1. func?containsCharacter(#string:?String,?#characterToFind:?Character)?->?Bool?{?
  2. ????for?character?in?string?{?
  3. ????????if?character?==?characterToFind?{?
  4. ????????????return?true?
  5. ????????}?
  6. ????}?
  7. ????return?false?
  8. }?

?

该函数对形參名的选择使得其函数主题更加清晰易读。而且在调用该函数时也不会有歧义:

  1. let?containsAVee?=?containsCharacter(string:?"aardvark",?characterToFind:?"v")?
  2. //?containsAVee?equals?true,?because?"aardvark"?contains?a?"v"?

?

默认形參值

你能够为不论什么形參定义默认值以作为函数定义的一部分。

假设已经定义了默认值,那么调用函数时就能够省略该行參。

注意:请在函数形參列表的末尾放置带默认值的形參。这将确保全部函数调用都使用顺序同样的无默认值实參。并让在每种情况下清晰地调用同样的函数。

这里有一个早期的join函数,并为參数joiner设置了默认值:

  1. func?join(string?s1:?String,?toString?s2:?String,?
  2. ????withJoiner?joiner:?String?=?"?")?->?String?{?
  3. ????????return?s1?+?joiner?+?s2?
  4. }?

?

假设在join函数调用时为joiner提供了字符串值,那么该字符串值能够用来连接两个字符串,就跟曾经一样:

  1. join(string:?"hello",?toString:?"world",?withJoiner:?"-")?
  2. //?returns?"hello-world"?

?

可是,假设函数调用时没有为joiner提供值,就会使用单个空格(" ")的默认值:

  1. join(string:?"hello",?toString:?"world")?
  2. //?returns?"hello?world"?

?

有默认值的外部形參名

在大多数情况下,为全部形參提供一个带默认值的外部名是很实用的(因此要求)。

假设在调用函数的时候提供了一个值,那么这将确保形參相应的实參有着明白的目的。

?

为了使这个过程更easy,当你自己没有提供外部名称时,Swift将为你定义的不论什么默认形參提供一个自己主动外部名。

这个自己主动外部名和本地名一样,就像你已经在本地名前加入了hash符号(#)一样。

?

这里有一个早期join函数版本号,没有为不论什么外部形參提供外部名,但仍然提供了joiner形參的默认值:

  1. func?join(s1:?String,?s2:?String,?joiner:?String?=?"?")?->?String?{?
  2. ????return?s1?+?joiner?+?s2?
  3. }?

?

在这样的情况下。Swift为带默认值的形參提供了外部形參名。当调用该函数的时候,外部形參名必须让形參的目的明白无歧义:

  1. join("hello",?"world",?joiner:?"-")?
  2. //?returns?"hello-world"?
?注意:在定义形參时,你能够通过使用下划线(_)来取代显示外部名称。

只是在适当的情况下。带有默认值形參的外部名一般是优先推荐的。

可变形參

一个可变形參可接受零个或多个指定类型的值。

当函数被调用时,你能够使用可变形參来指定--形參能够用来传递随意数量的输入值。可通过在形參的类型名后边插入三个点符号(...)来编写可变形參。

?

传递至可变形參的值在函数主体内是以适当类型的数组存在的。比如,一个可变參数的名称为numbers和类型为Double...在函数体内就作为名为numbers类型为Double[]的常量数组。

?

下边演示样例为不论什么长度的数字列表计算算术平均值:

  1. func?arithmeticMean(numbers:?Double...)?->?Double?{?
  2. ????var?total:?Double?=?0?
  3. ????for?number?in?numbers?{?
  4. ????????total?+=?number?
  5. ????}?
  6. ????return?total?/?Double(numbers.count)?
  7. }?
  8. arithmeticMean(1,?2,?3,?4,?5)?
  9. //?returns?3.0,?which?is?the?arithmetic?mean?of?these?five?numbers?
  10. arithmeticMean(3,?8,?19)?
  11. //?returns?10.0,?which?is?the?arithmetic?mean?of?these?three?numbers?
?注意:函数最多能够有一个可变形參,而且它必须出如今參数列表的最后。以避免使用多个形參调用函数引发歧义。

假设你的函数有一个或多个带有默认值的形參。而且还有可变形參,请将可变形參放在全部默认形參之后,也就是的列表的最末尾。

?

常量形參和变量形參

函数的形參默认是常量。试图在函数体内改变函数形參的值会引发一个编译时错误。这意味着你不能错误地改变形參的值。

?

可是有时候,函数有一个形參值的变量副本是很实用的。您能够指定一个或多个形參作为变量形參。从而避免在函数内部为自定义一个新的变量。变量參数是变量而很量,并给函数一个可改动的形參值副本。

?

在參数名称前用关键字var定义变量參数:

  1. func?alignRight(var?string:?String,?count:?Int,?pad:?Character)?->?String?{?
  2. ????let?amountToPad?=?count?-?countElements(string)?
  3. ????for?_?in?1...amountToPad?{?
  4. ????????string?=?pad?+?string?
  5. ????}?
  6. ????return?string?
  7. }?
  8. let?originalString?=?"hello"?
  9. let?paddedString?=?alignRight(originalString,?10,?"-")?
  10. //?paddedString?is?equal?to?"-----hello"?
  11. //?originalString?is?still?equal?to?"hello"?

这个样例定义了一个新函数叫做alignRight,用于将一个输入字符串和更长的输出字符串右边缘对齐。

全部左側的空白使用指定的占位符来填充。

在这个样例中。字符串"hello"被转化为字符串"-----hello"。

?

alignRight函数把输入的形參字符串定义成一个变量形參。这意味着字符串如今能够作为一个本地变量。用传入的字符串值初始化。而且能够在函数体中进行相应操作。

?

函数首先要找出有多少字符须要被加入到字符串的左側,从而在整个字符串中靠右对齐。这个值存储在本地常量amountToPad中。

该函数然后将填充字符的amountToPad个字符复制到现有的字符串的左边,并返回结果。

??注意:你对变量形參所做的改变不会比调用函数更持久,而且在函数体外是不可见的。变量形參仅存在于函数调用的声明周期中。

In-Out 形參

如上描写叙述。变量形參仅仅能在函数本身内改变。假设你想让函数改变形參值,并想要在函数调用结束后保持形參值的改变。那你能够把形參定义为in-out形參。

?

通过在形參定义的開始加入inout关键字来编写in-out形參。In-Out形參有一个传递至函数的值。由函数改动,并从函数返回来替换原来的值。

?

你仅仅能传递一个变量作为in-out形參相应的实參。你不能传递一个常量或者字面量作为实參。由于常量和字面量不能被改动。当你把变量作为实參传递给in out形參时。须要在直接在变量前加入 & 符号。以表明它能够被函数改动。

提示:in-out參数不能有默认值。可变參数的參数也不能被标记为inout。假设您标记參数为inout,它不能同一时候被标记为var或let。

这里的一个叫做swapTwoInts函数,它有两个称为a和b的in-out整型形參:

  1. func?swapTwoInts(inout?a:?Int,?inout?b:?Int)?{?
  2. ????let?temporaryA?=?a?
  3. ????a?=?b?
  4. ????b?=?temporaryA?
  5. }?

swapTwoInts函数仅仅是简单地交换a、b的值。该函数通过存储一个名为temporaryA暂时常量的值。指定b的值到a,然后分配temporaryA到b运行该交换。

?

你能够通过两个Int类型的变量调用swapTwoInts函数。从而交换它们的值。须要注意的是当它们被传递给swapTwoInts函数时,someInt和anotherInt名称前要加上前缀符号&:

  1. var?someInt?=?3?
  2. var?anotherInt?=?107?
  3. swapTwoInts(&someInt,?&anotherInt)?
  4. println("someInt?is?now?\(someInt),?and?anotherInt?is?now?\(anotherInt)")?
  5. //?prints?"someInt?is?now?107,?and?anotherInt?is?now?3"?

上面的样例表明,someInt和anotherInt的原始值由swapTwoInts函数进行了改动。即使它们定义在函数外部。

?注意:In-out形參不同于从函数返回一个值。

上边swapTwoInts样例未定义返回类型或者返回值,但它仍然会改动someInt和anotherInt的值。对函数来说,In-out形參是一个影响函数主体范围外的可选方式。

?

函数类型


每一个函数都有特定的函数类型,由函数的形參类型和返回类型组成。比如:

  1. func?addTwoInts(a:?Int,?b:?Int)?->?Int?{?
  2. ????return?a?+?b?
  3. }?
  4. func?multiplyTwoInts(a:?Int,?b:?Int)?->?Int?{?
  5. ????return?a?*?b?
  6. }?

这个样例中定义了两个简单的数学函数addTwoInts和multiplyTwoInts。每一个函数接受两个int值。并返回一个int值,运行适当的数学运算并返回结果。

?

这两个函数的类型都是(Int, Int)->Int。能够解读为:"这个函数类型,它有两个Int类型形參,并返回一个Int类型的值。"

?

以下是还有一个样例。该函数没有形參或返回值:

  1. func?printHelloWorld()?{?
  2. ????println("hello,?world")?
  3. }?

这个函数的类型是()->(),或者"没有形參的函数。并返回void。"没有指明返回值的函数一般会返回void,在swift中相当于一个空元组,显示为()。

?

使用函数类型

在swift中您能够像不论什么其它类型一样的使用函数类型。比如。你能够定义一个常量或变量为一个函数类型,并为变量指定一个相应的函数:

  1. var?mathFunction:?(Int,?Int)?->?Int?=?addTwoInts?

能够解读为:"定义一个名为mathFunction变量,该变量的类型为‘一个函数,它接受两个Int值,并返回一个Int值。‘设置这个新的变量来引用名为addTwoInts函数。"

?

该addTwoInts函数具有与mathFunction同样类型的变量,所以这个赋值在能通过swift的类型检查。

?

如今你能够使用mathFunction来调用指定的函数:

  1. println("Result:?\(mathFunction(2,?3))")?
  2. //?prints?"Result:?5"?

?

具有同样匹配类型的不同函数能够被赋给同一个变量,和非函数类型一样:

  1. mathFunction?=?multiplyTwoInts?
  2. println("Result:?\(mathFunction(2,?3))")?
  3. //?prints?"Result:?6"?

?

与其它类型一样,当你给函数赋一个常量或者变量时。你能够让Swift去判断函数的类型。 ? ?

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

?

作为形參类型的函数类型

您能够使用一个函数类型,如(Int, Int)->Int作为还有一个函数的形參类型。这使你预留了一个函数的某些方面的函数实现。让调用者提供的函数时被调用。

?

下边的样例打印了上边的数学函数的结果:

  1. func?printMathResult(mathFunction:?(Int,?Int)?->?Int,?a:?Int,?b:?Int)?{?
  2. ????println("Result:?\(mathFunction(a,?b))")?
  3. }?
  4. printMathResult(addTwoInts,?3,?5)?
  5. //?prints?"Result:?8"?

这个样例中定义了一个名为printMathResult函数,它有三个形參。

第一个形參名为mathFunction,类型为(Int, Int)->Int。您能够传递不论什么同类型的函数作为第一个形參的实參。

第二和第三个參数a、b都是int类型。

被用来作为数学函数的两个输入值。

?

当printMathResult被调用时,它传递addTwoInt函数,以及整数值3和5。它使用3和5调用了提供的函数,打印的结果是8。

?

printMathResult的作用是打印调用适当类型的数学函数的结果。该函数真正实现了什么并不重要--它仅仅关心函数的类型是正确的。这使得printMathResult以一种安全类型的方式把自身的功能转换至函数的调用者。

?

作为返回类型的函数类型

你能够将一个函数类型作为还有一个函数的返回类型。

你能够在返回函数的返回箭头(->) 后马上编写一个完整的函数类型来实现。

?

以下的样例定义了两个简单的函数调用stepForward和stepBackward。

stepForward函数返回一个输入值+1的结果,而stepBackward函数返回一个输入值-1的结果。这两个函数都有一个同样的(Int) -> Int类型 :

  1. func?stepForward(input:?Int)?->?Int?{?
  2. ????return?input?+?1?
  3. }?
  4. func?stepBackward(input:?Int)?->?Int?{?
  5. ????return?input?-?1?
  6. }?

?

这里有一个chooseStepFunction函数,它的返回类型是"函数类型(Int) -> Int"。chooseStepFunction基于名为backwards的布尔形參返回stepBackward或stepForward函数:

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

?

你如今能够使用chooseStepFunction获取一个函数,可能是递增函数或递减函数:

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

前面的样例能够计算出是否须要通过递增或者递减来让currentValue变量趋于零。currentValue的初始值为3,这意味着currentValue > 0返回为真,而且chooseStepFunction返回stepBackward函数。

返回函数的引用存储在一个名为moveNearerToZero的常量里。

?

如今moveNearerToZero运行了正确的功能,就能够用来计数到零:

  1. println("Counting?to?zero:")?
  2. //?Counting?to?zero:?
  3. while?currentValue?!=?0?{?
  4. ????println("\(currentValue)...?")?
  5. ????currentValue?=?moveNearerToZero(currentValue)?
  6. }?
  7. println("zero!")?
  8. //?3...?
  9. //?2...?
  10. //?1...?
  11. //?zero!?

?

嵌套函数


迄今为止全部你在本章中遇到函数都是全局函数,在全局作用域中定义。事实上你还能够在其它函数体中定义函数,被称为嵌套函数。

?

嵌套函数默认对外界是隐藏的,但仍然能够通过它们包裹的函数调用和使用它。enclosing function也能够返回一个嵌套函数,以便在其它作用域中使用嵌套函数。

?

你能够重写上面的chooseStepFunction样例使用并返回嵌套函数:

  1. func?chooseStepFunction(backwards:?Bool)?->?(Int)?->?Int?{?
  2. ????func?stepForward(input:?Int)?->?Int?{?return?input?+?1?}?
  3. ????func?stepBackward(input:?Int)?->?Int?{?return?input?-?1?}?
  4. ????return?backwards???stepBackward?:?stepForward?
  5. }?
  6. var?currentValue?=?-4?
  7. let?moveNearerToZero?=?chooseStepFunction(currentValue?>?0)?
  8. //?moveNearerToZero?now?refers?to?the?nested?stepForward()?function?
  9. while?currentValue?!=?0?{?
  10. ????println("\(currentValue)...?")?
  11. ????currentValue?=?moveNearerToZero(currentValue)?
  12. }?
  13. println("zero!")?
  14. //?-4...?
  15. //?-3...?
  16. //?-2...?
  17. //?-1...?
  18. //?zero!?

?

本章由CocoaChina的翻译小组成员?Da杯柠檬水(微博翻译,转载请注明出处和译者信息,拒绝商业之用。


Swift 属性 函数

原文:https://www.cnblogs.com/xfgnongmin/p/10749404.html

(0)
(0)
   
举报
评论 一句话评论(0
分享档案
最新文章
教程昨日排行
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!