【4858.com】Swift与OC的语法轻便相比较

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

 

 

0一-常量与变量

学习swift第2步打字与印刷Hello World

print(“Hello World”)

swift是决不加分号的

怎样是常量?

常量是在程序运维进度中无法退换值的量

怎么时变量?

变量是足以在程序运维进程中穿梭改变的量

在swift个中常量和变量必须在动用前声称

用let来声称常量,用var来声称变量

常量定义情势:

能够用别样你喜爱的字符作为常量和变量名,包蕴Unicode字符

常量与变量名不可能包涵以下:

数学符号,箭头,保留的(或然私下的)Unicode码位,连线与制表符。

也不能够以数字开始,可是足以在常量与变量名的别的地方含有数字。

小心:Swift中的常量必须在概念时开始化(OC能够不初阶化),不然会报错

letmax=10

let🐶=100

变量定义格局:

在OC个中先定义再初阶化————>(以下为OC写法)

intage;

age =10;

也得以定义的同时发轫化

intage =10;

在swift个中先定义再伊始化:

varage 那种写法会直接报错.

报错原因:(type annotation missing in pattern:未有点名数据类型)

在Swift中只要想要先定义1个变量,

从此未来选择时再最先化必须在概念时报告编译器变量的项目(类型标注)

写法为:

varage:Int

age = 20

概念的还要开头化:

在斯威夫特中一经定义的还要伊始化一个变量,能够不用写数据类型

编写翻译期会依靠早先化的值自动测算出变量的项目(品类估计机制)

varage:Int=20

varage =20


在求学斯威夫特的经过中,插足与OC的自己检查自纠,那样越来越好明白,回想.

/*

/*

02-基本数据类型

骨干数据类型

OC:

整型int intValue = 10;

浮点型double doubleValue = 10.10; float floatValue = 5.1;

长long

短short

有符号signed

无符号unsigned

各连串型的数据的取值范围在不一致位的编写翻译器下取值范围不相同

Swift:注意关键字大写

整型

varintValue:Int=10

浮点型

varintValue一:Double=十.10意味着陆16人浮点数

varintValue二:Float=玖.九象征三12位浮点数

若果遵照长度划分,Swift中的长短比OC尤其正确

varintValue3:Int8=6

varintValue4:Int16=7

varintValue5:Int32=8

varintValue6:Int64=9

有记号无符号,默许是有号子的(UInt8/UInt16/UInt32/UInt64)

varuintValue7:UInt=10

专注:无符号的数比有号子的取值范围越来越大,因为符号位也用来存值

Swift是种类安全的语言,假设取值错误会一向报错,而OC不会

取值不对

OC:unsignedintintValue = -10;不会报错

Swift:varintValue:UInt= -10会报错

溢出:

OC:intintValue =INT_MAX+1;不会报错

Swift:varintValue:UInt=UInt.max +1会报错

数据类型的互相赋值(隐式类型转变)

OC能够隐式类型调换

intintValue =10;

doubledoubleValue = intValue;

Swift:不抱有隐式类型转变

在Swift中“值恒久不会被隐式转变为其它品类”(OC中得以隐式类型调换)

以下语句会报错

varintValue:Int=10

vardoubleValue:Double= intValue

数据类型转变**

斯维夫特不容许隐式类型转变,但足以应用展现类型转变(强制类型转变)

OC写法

intintValue =10;

doubledoubleValue = (double)intValue;

Swift写法:

varintValue:Int=10

vardoubleValue:Double

doubleValue=Double(intValue)

留神:Double()并不会修改intValue的值

而是经过intValue的值生成多个一时的值赋值给doubleValue

print(intValue)

print(doubleValue)


1.0 if和switch分支:

 for循环

 for循环

03- 运算符

算术运算符:

+ – * / % ++ —

除却取模,其余和OC同样,包蕴预先级

varresult =10+10

result =10*10

result =10-10

【4858.com】Swift与OC的语法轻便相比较。result =10/10

print(result)

专注:Swift是安枕而卧严刻的编制程序语言,会在编写翻译时等候检查查是或不是溢出

可是只会检讨字面量而不会检讨变量

由此在Swift中必定要留心隐式溢出

欣逢那种难题得以选择溢出运算符消除该难题:

http://www.yiibai.com/swift/overflow\_operators.html

取模%

OC:只可以对整数取模

NSLog(@”%tu”,10%3);

Swift:支持小数取模

print(10%3.5)

自增自减

varnumber =10

number++

print(number)

number–

print(number)

赋值运算

varnum1 =10

num1 =20

num1 +=10

num1 -=10

num1 /=10

num1 *=10

num1 %=5

print(num1)

骨干用法和OC同样,唯一要注意的是表明式的值

OC:表明式的整合方向是从左至右

全副表明式的值全体的值等于最终3个变量的值,简单的讲正是连接赋值

写法为:

intnum1;

intnum2;

num2 = num1 =10;

NSLog(@”%d”,num2);

Swift:不允许接二连三赋值, Swift中的整个表明式是从未值的.

第3是为了幸免if (c == 玖)

那种景况误写为if (c = 九) ,c = 九是一个表明式,表明式是未曾值的

所以在Swift中if (c = 9)不成立

上边那些写法是在swift当中不容许的

varnum1:Int

varnum2:Int

num2 = num1 =10

事关运算符

> < >= <= == != ?:

涉及运算符,得出的值是Bool值,基本用法和OC同样

varresult1:Bool=250>100

varresult2 =250>100?250:100

print(result2)

逻辑运算符

C语言和OC并不曾真正的Bool类型

C语言的Bool类型非0即真

OC语言的Bool类型是typedef signed char BOOL;

Swift引进了真正的Bool类型

Bool true false

Swift中if的标准只好是三个Bool的值只怕是再次回到值是Bool类型的表明式

OC中if能够是其余整数(非0即真),

只是存在的难题是唯恐将剖断写错,写成了赋值if(isOpen = 二)

在付出中为了制止那几个难题

有经验的程序猿会那样写if(二 == isOpen)来制止这几个难点.

在斯维夫特中很好的化解了那几个标题

逻辑运算符在swift个中只好操作Bool类型数据

在OC个中是非0即真.能够操作整形

在swift个中不容许那种操作.其余基本和OC一致

varopen =false

if!open

{

print(“打开”)

}

varage =20

varheight =180

varwage  =30000

if(age >25&& age <40&& height >175) || wage >20000

{

print(“恒仔”)

}

区间

闭区间:包蕴区间内具有值a…b比如: 一…5

半闭间隔:蕴含头不含有尾a..

注意: 1.斯维夫特刚出来时的写法是a..b

2.区间只可以用来整数,写小数会有标题

foriin1…5

{

print(i)

}

foriin1..<5

{

print(i)

}


–if:

/*Swift中的if和OC中的if”差不离”一模一样

* Swift中的if能够省略前边的圆括号

* OC中的if倘诺前面唯有一条语句, 那么大括号能够轻松, 而斯维夫特中那多少个

* OC中的条件表明式非0即真, 而Swift中相当

* 斯维夫特中提供了真正的Bool类型, true/false,
条件表明式的值必须是true/false

*/

let num = 10

if (num == 10)

{

print(“number等于10”)

}

if num == 10

{

print(“number等于10”)

}

/*:

Switch

* switch前边的圆括号能够简单

* 如若是在OC中各样case前面不写break, 导致穿透. 而在Swift中不会

* 即使是在OC中想在case后边定义变量, 必须抬高{}表达作用域,
而在Swift中不要表达成效域

* 假若是在OC中default的职位能够不管写, 而在斯威夫特中不容许

* 假若是在OC中default能够不用写, 而在斯威夫特中山大学部场合下是必须写的

*/

let value = 3

switch value

{

case 0:

print(“0”)

var i = 10

case 1:

print(“1”)

case 2:

print(“2”)

case 3:

print(“3”)

case 4:

print(“4”)

default:

print(“other”)

}

 格式: for (开始化表明式;循环境保护持规范;循环后表明式) {必要推行的话语}

 格式: for (起首化表明式;循环境保护持标准;循环后表明式) {要求施行的说话}

04- 元组

何以是元组

在其他语言中很已经是有元组那些定义,可是对于OC程序猿来讲那是多个新的概念

官方概念:元组(tuples)把七个值组合成八个复合值。

元组内的值能够是随便等级次序,并不供给是一致等级次序。

将八个一律或许差异品种的值用1个小括号括起来就是2个元组

概念元组

letstudent = (“lzh”,30,99.8)

print(student)

print(student.0)

print(student.1)

print(student.2)

元组其实和结构体很像,只是不要求超前定义类型.

元组其实是复合类型,小括号中得以写任意等级次序

也得以钦赐数据类型

如若钦点了数据类型,那么相应的必须是任何定的数据类型,不然会报错.

letstudent: (String,Int,Double) = (“lzh”,30,99.8)

概念元组别的措施

指明元组成分的称号

letstudent = (name:”lzh”,age:30,score:99.8)

print(student.name)

print(student.age)

print(student.score)

经过点名的称谓提取元组对应的值,会将对应地方的值赋值给相应地点的名目

let(name , age , score) =  (“lzh”,30,99.8)

print(name)

print(age)

print(score)

万1不关怀元组中的有个别值能够动用_通配符来忽略提取

letstudent = (“lzh”,10,20)

let(name , age ,_) = student

print(name)

print(age)

在在此之前从未有过元组以前C和OC语言是由此传播指针只怕再次回到结构体的艺术来回到七个值的

而有了元组之后就足以完毕让三个函数再次来到七个值


1.1 分支相关:

/*:

三目运算符

* 格式: 条件发挥式 ? 取值壹 : 取值二

* 注意: 运算符之间要求有空格

* 提示: 在斯维夫特开拓中三目运算符用得尤其多

*/

let num = 7

let res = (num == 10) ? 10 : 5

/*:

可选类型(Optional)

即使见到数据类型前面有 ? !

* 含义: 能够有值也能够没有值, 唯有可选类型的变量手艺赋值nil

* convenience init? 重返三个可选类型的值

* 注意: 要是出口可选类型的值, 会包装多个Optional

* 假若在变量的前面加上1个!, 代表报告系统该变量一定有值

* !称之为强制解包

* 注意: 固然可选类型的变量中没有值, 而又开始展览了挟持解包,
那么会掀起一个周转时的不当

* 开拓手艺: 作为初学者, 不要去纠结? ! ??那个标志,
初期利用Xcode开辟工具提示来缓慢解决这几个难点, 早先时期再深远钻研怎么时候使用?
几时利用!

*/

let url = NSURL(string: “”)

print(url!)

let url2 = NSURL(string: “”)

//print(url2!)

if url != nil

{

print(url!)

}

/*

机关解包

* 假诺数据类型前面写的是!, 那么在接纳该变量时系统会自行给我们解包

*/

let url4: NSURL! = NSURL(string: “”)

print(url4)

// 注意点: 数据类型后边不要随便增加!, 因为若是未有值会报错

let url5: NSURL! = NSURL(string: “”)

//print(url5)

/*:

可选绑定

* 格式: if let 变量名称 = 可选类型变量 {}

* 优点: 只要能进来大括号, 那么可选类型变量就必将有值

*/

if let url3 = url

{

// 在if中不要对url三拓展强制解包,
因为在赋值的进程中系统已经帮我们解包了

print(url3)

}

 OC:

 OC:

05- 可选值

使用可选类型(optionals)来管理值大概缺点和失误的情形。

C 和 Objective-C 中并从未可选类型这一个定义。

最接近的是 Objective-C 中的三个表征,

叁个措施要不回来1个对象要不回来nil,nil表示“缺乏贰个官方的靶子”

**可选值: optionals有三种境况:**

1.有值

2.并未有值,未有值正是nil

?表示二种景况,1种是有值(有具体的某些值)

1种是绝非值(未有代表为nil)

当为?修饰时,申明这些变量有不小希望为nil

有值

varoptValue:Int? =9

没有值

varoptValue:Int?

varoptValue:Int? =nil

**可选值能够行使if语句来举办判别**

varoptValue:Int? =10

ifoptValue !=nil

{

print(“有值:\(optValue)”)

}else

{

print(“没有值:\(optValue)”)

}

输出结果:有值:Optional(10)

varoptValue:Int?

ifoptValue !=nil

{

print(“有值:\(optValue)”)

}else

{

print(“没有值:\(optValue)”)

}

出口结果:没有值:nil

varoptValue:Int?=nil

ifoptValue !=nil

{

print(“有值:\(optValue)”)

}else

{

print(“没有值:\(optValue)”)

}

出口结果:没有值:nil

**提取可选类型的值(使用!强制解析)**

将optValue中的整型值强制拿出去赋值给变量result,

换句话说正是告诉编写翻译器optValue一定有值

因为可选类型有两种状态有值和未有值,所以供给报告编写翻译器到底有未有值

急需小心的是一旦强制解析optValue

不过optValue中平素不值时会引发多少个运营时不当

varoptValue:Int? =9

varresult:Int=optValue!

print(result)

输出结果:玖

varoptValue6:Int?

varresult2:Int=optValue6!

print(result2)

结果为报错:

fatal error:

unexpectedly found nil while unwrapping an Optional value

可选绑定

为了更安全的剖析可选类型的值,一般意况下采用可选绑定

即使optValue未有值就不会做其余操作

尽管optValue有值会重返true并将optValue的值赋值给result奉行大括号中的内容

varoptValue:Int? =9

ifletresult =optValue

{

print(result)

}


壹.二 循环相关:

/*:

Swift中的循环和OC中的循环 “基本”1致

for

while

do while  — > Swift是 repeat while

*/

//: 常规写法

// 其它特点和if同样

for var i = 0; i < 10; i++

{

print(i)

}

//: Swift中的写法

// 前边的 0..<10 称之为半壁区间

// 半闭区间特点: 包括头不含有尾

for i in 0..<10

{

print(i)

}

// 闭区间: 包涵头包罗尾

// 注意点: …/..< 中间不能够有空格

for i in 0…10

{

print(i)

}

// while: 斯维夫特开垦中很少使用while

var index = 0

while index < 10

{

print(index)

index++

}

// repeat while

var i = 0

repeat{

print(i)

i++

}while(i < 10)

 int sum = 0;

 int sum = 0;

0陆-字符和字符串

字符

OC在那之中的字符:charcharValue =’a’;

swift当中的字符:varcharValue一:Character=”a”

斯维夫特和OC字符差异样

一.Swift是用双引号

二.Swift中的字符类型和OC中的也不等同

OC中的字符占3个字节,因为它只含有ASCII表中的字符

而斯威夫特中的字符除了能够储存ASCII表中的字符仍是能够存储unicode字符.

OC的字符是信守ASCII标准的,Swift的字符是遵循unicode标准的

故而能够存放时间上保有国家语言的字符(大多数)

OC当中:charcharValue =’李’;错误

swift当中:varcharValue2:Character=”李”正确

瞩目:双引号中只好放3个字符,如下是错误写法

varcharValue3:Character=”ab”

字符串

C:

char*stringValue =”ab”;

charstringArr =”ab”;

OC:

NSString*stringValue =”ab”;

Swift:

varstringValue1 =”ab”

C语言中的字符串是以\0结尾的,例如:

char*stringValue =”abc\0bcd”;

printf(“%s”, stringValue);

输出结果:abc

OC语言中的字符串也是以\0结尾的,例如:

NSString*stringValue =@”abc\0bcd”;

NSLog(@”%@”, stringValue);

swift当中的字符串和C语言/OC语言中的字符串是差别的

varstringValue =”abc\0bcd”

print(stringValue)

输入结果:abcbcd

字符串常用方法

计算字符串长度:

C:

char*stringValue =”abc李”;

printf(“%tu”,strlen(stringValue));

输出结果:陆

OC:

NSString*stringValue =@”abc李”;

NSLog(@”%tu”, stringValue.length);

出口结果:四以UTF1陆计算

swift:

varstringValue =”abc李”

print(stringValue.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

出口结果:陆和C语言一样总结字节数

字符串拼接

C:

charstr1[] =”abc”;

char*str2 =”bcd”;

char*str =strcat(str1, str2);

printf(“%s”,str);

输出结果:abcbcd

OC:

NSMutableString*str1 = [NSMutableStringstringWithString:@”abc”];

NSString*str2 =@”bcd”;

[str1appendString:str2];

NSLog(@”%@”, str1);

出口结果:abcbcd

swift:

varstr1 =”g”;

varstr2 =”gxq”;

varstr =str1+str2;

print(str)

出口结果:ggxq

格式化字符串

OC:

NSString*str =

[NSMutableString

stringWithFormat:@”];

NSLog(@”%@”, str);

输入结果:http://ios.564697292@qq.cn/pic/10.png

swift:

varindex =10

varstr
=”http://www.564697292@qq.com/pic/\(index).png”

print(str)

输入结果:http://www.564697292@qq.com/pic/10.png

字符串比较:

oc:

NSString*str1 =@”abc”;

NSString*str2 =@”abc”;

if([str1compare:str2] ==NSOrderedSame)

{

NSLog(@”相等”);

}else

{

NSLog(@”不相等”);

}

输出结果:相等

NSString*str1 =@”abc”;

NSString*str2 =@”abc”;

if([str1isEqualToString:str2])

{

NSLog(@”相等”);

}else

{

NSLog(@”不相等”);

}

输出结果:相等

Swift:(== / != / >= / <=),和C语言的strcmp一样是种种相比

varstr1 =”abc”;

varstr2 =”abc”;

ifstr1 == str2

{

print(“相等”);

}else

{

print(“不相等”);

}

出口结果:相等

varstr1 =”abd”;

varstr2 =”abc”;

ifstr1 >= str2

{

print(“大于等于”);

}else

{

print(“不超出等于”);

}

输出结果:凌驾等于

看清前后缀

OC:

NSString*str
=@”http://564697292@qq.com”;

if([strhasPrefix:@”http”]) {

NSLog(@”是url”);

}

if([strhasSuffix:@”.cn”]) {

NSLog(@”是头号域名”);

}

出口结果:是url

是一等域名

Swift:

varstr
=”http://www.564697292@qq.com”

ifstr.hasPrefix(“http”) {

print(“是url”);

}

ifstr.hasSuffix(“.com”) {

print(“是超级域名”);

}

输出结果:是url

是头等域名

大大小小写转变

OC:

NSString*str =@”abc.txt”;

NSLog(@”%@”, [struppercaseString]);

NSLog(@”%@”, [strlowercaseString]);

出口结果:ABC.TXT

abc.txt

Swift:

varstr =”abc.txt”;

print(str.uppercaseString)

print(str.lowercaseString)

出口结果:ABC.TXT

abc.txt

退换为主导数据类型

OC:

NSString*str =@”250″;

NSIntegernumber = [strintegerValue];

NSLog(@”%tu”, number);

输出结果:250

万壹str不可能调换为整数,那么可选类型再次回到nil

str = “250sb”不能够改换所以可能为nil

varstr =”250″

varnumber:Int? =Int(str)

ifnumber !=nil

{

发轫的本子println会自动拆包,未来的不会

print(number!)

}


1.3 数组有关:

/*:

数组

* 格式: []

* 注意点: let 不可变数组 var 可变数组

*/

let arr1 = [“10”, “20”, “30”]

// 特点: 自动将着力数据类型转变为指标类型

var arr2 = [10, “20”, 99.9]

// 获取

print(arr2[1])

// 修改

arr2[2] = 100

arr2

// 追加

arr2.append(33)

// 删除, 数组的删减方法会将被去除的因素重返给我们

arr2.removeAtIndex(0)

arr2

// keepCapacity: 删除数组中的成分, 是还是不是必要保证数组原有的容积,
假诺传入false代表不保持容积

arr2.removeAll(keepCapacity: false)

arr2.capacity

// 注意点: 数组增添体积长久是在原本体量的功底上*2

arr2.append(1)

arr2.capacity

arr2.append(2)

arr2.capacity

arr2.append(3)

arr2.capacity

// 合并

var arr3 = [1, 3, 5]

var arr4 = [2, 4, 6]

arr3 += arr4

arr3

//var arr5 = [“8”, “9”]

//arr3 += arr5

for item in arr3

{

print(item)

}

 for (int i = 0; i <= 10; i++) {

 for (int i = 0; i <= 10; i++) {

07- 数组



**数组定义:**

OC:

有值数组

NSArray*arr0 =@[@1,@2,@3];

NSArray*arr1 = [NSArrayarrayWithObjects:@1,@2,@3,nil];

NSLog(@”%@”, arr1);

输出结果:

2016-01-06 01:04:49.180 test[11687:2096671] (

1,

2,

3

)

空数组

NSArray*arr =@[];

NSArray*arr1 = [NSArrayarray];

NSLog(@”%@”, arr1);

输出结果:

2016-01-06 01:06:04.132 test[11703:2106199] (

)

**不可变数组:NSArray**

**可变数组:NSMutableArray**

swift:

有值数组

vararr0 = [1,2,3]

vararr1:Array= [1,2,3]

vararr2:Array = [1,2,3]

vararr3: [Int] = [1,2,3]

print(arr3)

输出结果:[1, 2, 3]

空数组

vararr5 = []

vararr6 = [Int]()

vararr7 =Array()

print(arr7)

出口结果:[]

可变数组:

vararr8 = []

不可变数组:

letarr9  = []

要素类型

OC:

NSArray*arr =@[@1,@”gxq”,@130];

NSLog(@”%@”, arr);

出口结果:

2016-01-06 01:13:07.987 test[11891:2163044] (

1,

gxq,

130

)

swift:

vararr = [1,”gxq”,130]

print(arr)

输出结果:[1, gxq, 130]

举个例子想显著表示数组中存放的是例外连串的数量

能够动用Any关键字,表示数组中得以存放区别门类的多少

vararr:Array = [1,”gxq”,130]

print(arr)

输出结果:[1, gxq, 130]

点名数组其中只可以存放Int型,假设存放别的品类会一贯报错

vararr:Array = [1,10,130]

print(arr)

出口结果:[1, 10, 130]


1.4 字典:

/*

字典

* OC @{key:value}

* Swift [key:value]

* 和数组一样, 假使用let修饰就是不可变字典, 要是用var修饰正是可变字典

*/

// 开垦本领: 在iOS开垦中选择功能最高的就是 [String: AnyObject]

let dict1 = [“name”: “stone”, “age”: 3]

var dict2:[String: AnyObject]

dict2 = [“name”: “stone”, “age”: 3]

// 获取

// 注意点: 从字典中抽出的值都以可选类型的值

// 因为经过三个key取值, 只怕取得到, 也恐怕取不到,
所以再次回到贰个可选类型的值

// 如果!写在[]末尾, 代表抽取来的值一定有值

// 如果!写在dict后边, 代表dict一定有值

print(dict2[“name”]!)

// 更新

dict2[“name”] = “stone”

dict2

// 添加

// 也正是说, 要是key存在正是创新, 倘若key不设有即是增多

dict2[“score”] = 99

dict2

// 遍历

for key in dict2.keys

{

print(dict2[key])

}

// 会将字典中的key赋值给()中的第一个变量

// 会将字典中的value赋值给()中的第1个变量

// 注意: k/v随便写

// ()括起来的事物我们称为元祖, 元祖是Swift中新添的一种数据类型

for (xx, oo) in dict2

{

print(xx)

print(oo)

}

// 合并

var dict3:[String: AnyObject] = [“name”: “stone”, “age”: 3]

var dict4:[String: AnyObject] = [“score”: 99]

// 字典无法像数组一样通过+=来统壹

//dict3 += dict4

for (k, v) in dict3

{

dict4[k] = v

}

dict4

 sum = i++;

 sum = i++;

0八-数组操作

得到长度

OC:

NSArray*arr =@[@1,@2,@3];

NSLog(@”%tu”, arr.count);

出口结果:2016-01-06 01:19:54.874 test[12086:2209180] 3

swift:

vararr = [1,2,3]

print(arr.count)

输出结果:三

判定是否为空

OC:

NSArray*arr =@[];

NSLog(@”result = %d”, arr.count!=0);

输出结果:2016-01-06 01:25:14.252 OCTest[12249:2255010] result = 0

swift:

vararr = [1,2,3]

print(arr.isEmpty)

输出结果:false

检索

OC:

NSArray*arr =@[@1,@2,@3];

NSLog(@”%@”, arr[0]);

出口结果:2016-01-06 01:26:46.816 OCTest[12275:2269853] 1

swift:

vararr = [1,2,3]

print(arr[0])

出口结果:1

追加

OC:

NSMutableArray*arr =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arraddObject:@4];

NSLog(@”%@”, arr);

输出结果:

2016-01-06 01:28:47.111 OCTest[12297:2286198] (

1,

2,

3,

4

)

swift:

vararr = [1,2,3]

arr.append(4);

print(arr)

输出结果:[1, 2, 3, 4]

vararr = [1,2,3]

arr+= [4]

print(arr)

出口结果:[1, 2, 3, 4]

vararr = [1,2,3]

arr+= [4]

arr+= [5,6,7]

出口结果:[1, 2, 3, 4, 5, 6, 7]

vararr = [1,2,3]

arr+= [4]

arr+= [5,6,7]

arr+=arr[0…3]

print(arr)

输出结果:[1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4]

插入

OC:

NSMutableArray*arr =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arrinsertObject:@4atIndex:0];

NSLog(@”%@”, arr);

输出结果:

2016-01-06 01:36:10.450 OCTest[12374:2339079] (

4,

1,

2,

3

)

swift:

vararr = [1,2,3]

arr.insert(4, atIndex:0);

print(arr)

出口结果:[4, 1, 2, 3]

更新

OC:

NSMutableArray*arr =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

arr[0] =@8;

NSLog(@”%@”, arr);

出口结果:

2016-01-06 01:37:28.482 OCTest[12397:2350177] (

8,

2,

3

)

swift:

vararr = [1,2,3]

arr[0] =8

print(arr)

出口结果:[8, 2, 3]

删除

OC:

NSMutableArray*arr1 =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arr1removeObject:@1];

NSLog(@”%@”, arr1);

NSMutableArray*arr2 =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arr2removeLastObject];

NSLog(@”%@”, arr2);

NSMutableArray*arr3 =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arr3removeAllObjects];

NSLog(@”%@”, arr3);

输出结果:

2016-01-06 01:39:49.831 OCTest[12418:2370779] (

2,

3

)

2016-01-06 01:39:49.832 OCTest[12418:2370779] (

1,

2

)

2016-01-06 01:39:49.832 OCTest[12418:2370779] (

)

swift:

vararr1 = [1,2,3]

arr1.removeAtIndex(0)

print(arr1)

vararr2 = [1,2,3]

arr2.removeLast()

print(arr2)

vararr3 = [1,2,3]

是或不是维持体积,倘使为true,尽管删除了体积依旧存在,体积是二的翻番

arr3.removeAll(keepCapacity:false)

print(arr3)

print(arr3.capacity)

出口结果:

[2, 3]

[1, 2]

[]

0

Range

OC:

NSMutableArray*arr =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

[arrremoveObjectsInRange:NSMakeRange(0,2)];

NSLog(@”%@”, arr);

出口结果:

2016-01-06 01:43:17.863 OCTest[12441:2396986] (

3

)

swift:

vararr = [1,2,3]

arr.removeRange(Range(start:1, end:2))

print(arr)

出口结果:[1, 3]

vararr = [1,2,3]

arr.removeRange(0…0)

print(arr)

出口结果:[2, 3]

varrange =0…5

print(range)

输出结果:0..<6


一.伍 字符串相关:

import UIKit

/*:

字符串

* OC: @””

* Swift: “”

* 特点:

1.OC中的字符串是3个目的, 斯威夫特中的字符串是二个结构体

二.斯维夫特中的字符串的属性比OC中的高

3.虽说OC中的字符串是八个对象, 而Swift中的字符串是三个结构体,
然而在Swift开拓中得以在那七个数据类型之间飞速的拓展调换

*/

var str = “stone”

for c in str.characters

{

print(c)

}

// 字符串的拼接

let name = “stone”

let gender = “man”

// 目标: name = stone, gender = man

//NSLog(@”name = %@, gender = %@”, name, gender)

// 注意: 斯威夫特的print函数不帮助%i/%@等占位符

//print(“name = %@, gender = %@”, name, gender)

// Swift中拼接内容使用 \(必要拼接的数据)

print(“name = \(name), gender = \(gender)”)

// 10.987654321  –> 10.98

let dValue = 10.987654321

let res = String(format: “%.2f”, arguments: [dValue])

print(res)

// 15-09-07

let res2 = String(format: “%02d-%02d-%02d”, arguments: [15, 9, 7])

print(res2)

// 字符串截取

// 在Swift开拓中字符串截取是一件特别可怜可怜蛋疼的难题

// 提出: 在斯维夫特开辟中只要要截取字符串,
或然从前在OC中央银行使的措施在斯威夫特字符串中尚无,
建议先将斯威夫特字符串转换为OC字符串之后再使用

let str2 = “stoneleon”

//let str3 = str2 as NSString

//let str3: NSString = str2

let str4 = (str2 as NSString).substringWithRange(NSMakeRange(0, 4))

print(str4)

let str5:NSString = “user/desktop/abc.txt”

str5.pathExtension

 }

 }

**0九-数组的批量操作**



OC:

NSMutableArray*arr =

[NSMutableArrayarrayWithObjects:@1,@2,@3,nil];

NSRangerange =NSMakeRange(0,2);

[arrreplaceObjectsInRange:range

withObjectsFromArray:@[@99,@88,@77,@66]];

NSLog(@”%@”, arr);

出口结果:

2016-01-06 14:56:45.493 OCTest[3599:667081] (

99,

88,

77,

66,

3

)

swift:

vararr = [1,2,3]

arr.replaceRange(1..<2, with: [99,88,77,66])

print(arr)

输出结果:[1, 99, 88, 77, 66, 3]

vararr = [1,2,3]

arr.replaceRange(Range(start:0, end:2), with: [99,88,77,66])

print(arr)

输出结果:[99, 88, 77, 66, 3]

遍历

OC:

NSArray*arr =@[@1,@2,@3];

for(inti =0; i < arr.count; i++) {

NSLog(@”%@”, arr[i]);

}

输出结果:

2016-01-06 15:00:10.702 OCTest[3635:694273] 1

2016-01-06 15:00:10.703 OCTest[3635:694273] 2

2016-01-06 15:00:10.703 OCTest[3635:694273] 3

NSArray*arr =@[@1,@2,@3];

for(NSNumber*numberinarr) {

NSLog(@”%@”, number);

}

输出结果:

2016-01-06 15:03:43.192 OCTest[3684:723081] 1

2016-01-06 15:03:43.193 OCTest[3684:723081] 2

2016-01-06 15:03:43.194 OCTest[3684:723081] 3

swift:

vararr1 = [1,2,3]

forvari =0; i

{

print(arr1[i])

}

fornumberinarr1

{

print(number)

}

出口结果:

1

2

3

vararr2 = [1,2,3]

fornumberinarr2[0..<3]

{

print(number)

}

出口结果:

1

2

3


1.六 函数相关:

/*:

函数:

* 格式 func 函数名称(参数列表) -> 再次回到值类型 {}

*/

// 未有再次来到值未有参数的

func say() -> Void

{

print(“hello”)

}

say()

// 若是未有重返值还足以简写

// Void == ()

func say2() -> ()

{

print(“world”)

}

say2()

// 即便没有重返值, 那么重返值类型能够省略

func say3()

{

print(“stone”)

}

say3()

// 有再次回到值未有参数的

// 注意点: 重回值类型必须和重回的值保持一致

func getMax() ->Int

{

return 998

}

print(getMax())

// 未有再次来到值有参数的

// – (void)sum:(int)a b:(int)b;

// [self sum:10 b: 20];

// 从斯维夫特二.0发端, 会自动将第一个参数初始的参数名称作为艺术的价签

func sum(a: Int, b: Int)

{

print(“sum = \(a + b)”)

}

sum(10, b: 20)

// 单独钦点方法的价签(进步阅读性)

// 能够在中间参数的前头加上国外国语大学表参数名称

// 内部参数: a/b , 给函数内部选拔的

// 外部参数: x/y , 给调用者使用的

func sum2(x a: Int, y b: Int)

{

print(“sum = \(a + b)”)

}

sum2(x: 30, y: 30)

// Swift2.0之前

// 代表a/b既是内部参数也是表面参数

//func sum(#a: Int, #b: Int)

//{

//    print(“sum = \(a + b)”)

//}

//sum2(a: 30, b: 30)

// 默认值

// 若是钦点了私下认可值, 那么调用的时候能够忽略, 假若忽略会动用暗中同意值

// 在其他语言中其实已经有暗许值的概念了,
在任何语言中的默许值只可以写在形参列表的尾声面

// 不过Swift中的暗许值能够写在随心所欲地点

func sum3(a: Int, b: Int = 110)

{

print(“sum = \(a  + b)”)

}

//sum3(50, b: 10)

sum3(50)

func sum4(a: Int = 88, b: Int = 100)

{

print(“sum = \(a  + b)”)

}

//sum4(b: 88)

sum4()

// 有重回值有参数的

func sum5(a: Int, b: Int) -> Int

{

return a + b

}

print(sum5(20, b: 20))

未完待续…

 NSLog(@”%d”, sum);

 NSLog(@”%d”, sum);

10-字典

概念字典

OC:

NSDictionary*dict =[NSDictionarydictionaryWithObject:

@”gxq”forKey:@”name”];

NSLog(@”%@”, dict);

出口结果:

2016-01-06 15:09:11.214 OCTest[3773:761032] {

name = gxq;

}

NSDictionary*dict =[NSDictionarydictionaryWithObjectsAndKeys:

@”name”,@”gxq”,

@”age”,@20,nil];

NSLog(@”%@”, dict);

输出结果:

2016-01-06 15:13:39.853 OCTest[3831:792730] {

gxq = name;

20 = age;

}

NSDictionary*dict =@{@”name”:@”gxq”,@”age”:@20};

NSLog(@”%@”, dict);

输出结果:

2016-01-06 15:14:57.616 OCTest[3841:801710] {

age = 20;

name = gxq;

}

swift:

key一定如若能够hash的(String, Int, Float, Double, Bool)

value未有须求

vardict = [“name”:”gxq”,”age”:20]

print(dict)

vardict1:Dictionary= [“name”:”gxq”,”age”:20]

print(dict1)

vardict2:Dictionary = [“name”:”gxq”,”age”:20]

print(dict2)

vardict3:[String:AnyObject] = [“name”:”gxq”,”age”:20]

print(dict3)

vardict4:[String:AnyObject] =

Dictionary(dictionaryLiteral: (“name”,”gxq”), (“age”,20))

print(dict4)

出口结果:

[“age”: 20, “name”: gxq]

[“age”: 20, “name”: gxq]

[“age”: 20, “name”: gxq]

[“age”: 20, “name”: gxq]

[“age”: 20, “name”: gxq]

可变字典:

vardict5 = [:]

不可变字典:

letdict6  = [:]

字典操作

OC:

获取

NSDictionary*dict =@{@”name”:@”gxq”,@”age”:@20};

NSLog(@”%@”, dict[@”name”]);

出口结果:

2016-01-06 15:26:00.351 OCTest[3923:881138] gxq

修改

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”name”,@”gxq”,

@”age”,@20,nil];

dict[@”name”] =@”iversion”;

NSLog(@”%@”, dict[@”name”]);

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”name”,@”gxq”,

@”age”,@20,nil];

[dictsetObject:@”iversion”forKey:@”name”];

NSLog(@”%@”, dict[@”name”]);

出口结果:

2016-01-06 15:27:01.704 OCTest[3933:890317] iversion

2016-01-06 15:28:21.398 OCTest[3943:899613] iversion

swift:

获取

vardict = [“name”:”gxq”,”age”:20]

print(dict[“name”]!)

输出结果:gxq

修改

vardict = [“name”:”gxq”,”age”:20]

dict[“name”] =”iverson”

print(dict[“name”]!)

vardict1 = [“name”:”gxq”,”age”:20]

dict1.updateValue(“iverson”, forKey:”name”)

print(dict[“name”]!)

输出结果:

iverson

iverson

更新

updateValue重临二个可选类型

一旦字典中不存在须要创新的key,那么再次来到nil,假设存在重回原始值

vardict = [“name”:”gxq”,”age”:25]

ifletorignal =dict.updateValue(“iverson”, forKey:”name”)

{

print(dict[“name”]!)

print(orignal)

}

输出结果:

iverson

gxq

updateValue重回七个可选类型

假如字典中不存在供给革新的key,那么再次来到nil并且会将新的键值对增加到字典中

vardict = [“name”:”gxq”,”age”:25]

ifletorignal =dict.updateValue(“iverson”, forKey:”abc”)

{

print(dict[“abc”]!)

print(orignal)

}

print(dict)

出口结果:[“abc”: iverson, “age”: 25, “name”: gxq]

添加

OC:

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”name”,@”gxq”,

@”age”,@25,nil];

dict[@”height”] =@100;

NSLog(@”%@”, dict);

输出结果:

2016-01-06 15:35:11.734 OCTest[4025:946250] {

gxq = name;

25 = age;

height = 100;

}

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”name”,@”GXQ”,

@”age”,@30,nil];

[dictsetObject:@200forKey:@”height”];

NSLog(@”%@”, dict);

输出结果:

2016-01-06 15:36:15.768 OCTest[4035:953931] {

GXQ = name;

30 = age;

height = 200;

}

swift:

vardict = [“name”:”Gxq”,”age”:50]

dict[“height”] =160;

print(dict)

输出结果:[“height”: 160, “age”: 50, “name”: Gxq]

删除

OC:

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”lzh”,@”name”,

@30,@”age”,nil];

[dictremoveObjectForKey:@”name”];

NSLog(@”%@”, dict);

出口结果:

2016-01-06 15:40:37.801 OCTest[4058:981747] {

age = 30;

}

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”lzh”,@”name”,

@30,@”age”,nil];

[dictremoveAllObjects];

NSLog(@”%@”, dict);

出口结果:

2016-01-06 15:41:20.705 OCTest[4068:989096] {

}

swift:

vardict = [“name”:”gxq”,”age”:10]

dict.removeValueForKey(“name”)

print(dict)

出口结果:[“age”: 10]

removeValueForKey重临叁个可选类型

假若字典中不设有供给删除的key,那么再次回到nil并且不会实行别的操作

假如存在则删除key对应的值,并且再次回到被删除的值

vardict = [“name”:”gxq”,”age”:20]

ifletorignal =dict.removeValueForKey(“names”)

{

print(dict)

print(orignal)

}

print(dict)

输出结果:[“age”: 30, “name”: gxq]

vardict = [“name”:”gxq”,”age”:30]

dict.removeAll(keepCapacity:true)

遍历字典

OC:

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”gxq”,@”name”,

@40,@”age”,nil];[dictenumerateKeysAndObjectsUsingBlock:^(idkey,idobj,BOOL*stop)
{

NSLog(@”key = %@ value = %@”, key, obj);

}];

出口结果:

2016-01-06 15:45:59.810 OCTest[4117:1022823] key = name value =
gxq

2016-01-06 15:45:59.811 OCTest[4117:1022823] key = age value = 40

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”gxq”,@”name”,

@40,@”age”,nil];

NSArray*keys = [dictallKeys];

for(NSString*keyinkeys) {

NSLog(@”%@”, key);

}

出口结果:

2016-01-06 15:48:07.861 OCTest[4137:1039198] name

2016-01-06 15:48:07.862 OCTest[4137:1039198] age

NSMutableDictionary*dict =

[NSMutableDictionarydictionaryWithObjectsAndKeys:

@”gxq”,@”name”,

@40,@”age”,nil];

NSArray*keys = [dictallValues];

for(NSString*keyinkeys) {

NSLog(@”%@”, key);

}

输出结果:

2016-01-06 15:49:20.375 OCTest[4148:1049548] gxq

2016-01-06 15:49:20.376 OCTest[4148:1049548] 40

vardict1 = [“name”:”Gxq”,”age”:30]

for(key , value)indict1

{

print(“key =\(key) value =\(value)”)

}

输出结果:

key = age value = 30

key = name value = Gxq

vardict2 = [“name”:”Gxq”,”age”:40]

forkeyindict2.keys

{

print(“key =\(key)”)

}

输出结果:

key = age

key = name

vardict3 = [“name”:”Gxq”,”age”:50]

forvalueindict3.values

{

print(“value =\(value)”)

}

输出结果:

value = 50

value = Gxq


 

 

11-if语句

if言辞基本接纳**

OC:

intage1 =10;

intage2 =20;

intmax;

max = age2;

if(age1 > age2) {

max = age1;

}

NSLog(@”%d”, max);

出口结果:20

if(age1 > age2) {

max = age1;

}else

{

max = age2;

}

NSLog(@”%d”, max);

出口结果:20

假设唯有一条指令if后边的大括号能够差不多

Swift:

if条件表达式{指令}   if条件表达式{指令} else{指令}

0.if后的圆括号能够大致

一.只可以以bool作为规范语句

二.万一只有条指令if前边的大括号不能够简单

varage1:Int=10

varage2:Int=20

varmax:Int

max=age2;

ifage1>age2

{

max=age1

}

print(max)

输出结果:20

ifage1>age2

{

max=age1;

}else

{

max=age2;

}

print(max)

输出结果:20

多分支

floatscore =99.9;

if(score >=90) {

NSLog(@”优秀”);

}else

{

if(score >=60) {

NSLog(@”良好”);

}else

{

NSLog(@”不给力”);

}

}

输出结果:2016-01-06 16:08:05.833 OCTest[4239:1177565]优秀

if(score >=90) {

NSLog(@”优秀”);

}elseif(score >=60)

{

NSLog(@”良好”);

}else

{

NSLog(@”不给力”);

}

出口结果:2016-01-06 16:08:05.834 OCTest[4239:1177565]优秀

swift:

varscore =99.9;

ifscore>=90

{

print(“优秀”)

}elseifscore>=60

{

print(“良好”)

}else

{

print(“不给力”)

}

出口结果:优秀


 int sum = 0;

 int sum = 0;

12- while循环

while循环**

OC:

格式:while(循环境保护持标准){必要施行的口舌}

inti =0;

intsum =0;

while(i <=10) {

sum = i++;

}

NSLog(@”%d”,sum);

输出结果:十

inti =0;

intsum =0;

while(i <=10)

sum = i++;

NSLog(@”%d”, sum);

输出结果:拾

如果唯有一条指令while前边的大括号可以简轻易单

Swift:

0.while后的圆括号可以省略

一.只可以以bool作为基准语句

二.只要唯有条指令while前面的大括号无法省略

vari:Int=0

varsum:Int=0

while(i<=10)

{

sum=i++

}

print(“\(sum)”)

输出结果:10

vari1:Int=0

varsum1:Int=0

whilei1<=10

{

sum1=i1++

}

print(“\(sum1)”)

输出结果:10

do while循环**

inti =0;

intsum =0;

do{

sum = i++;

}while(i <=10);

NSLog(@”%d”, sum);

输出结果:10

inti =0;

intsum =0;

do

sum = i++;

while(i <=10);

NSLog(@”%d”, sum);

出口结果:10

要是只有一条指令while前面包车型地铁大括号能够省略

swift:

Swift贰.0事后成为repeat while, do用于捕捉非常

0.while后的圆括号能够总结

一.只可以以bool作为规范语句

2.比如只有条指令do前面包车型客车大括号不得以回顾

vari2:Int=0

varsum2:Int=0

repeat{

sum2=i2++;

}while(i2<=10)

print(sum2)

出口结果:十

vari3:Int=0

varsum3:Int=0

repeat{

sum3=i3++;

}whilei3<=10

print(sum3)

输出结果:10


 int i = 0;

 int i = 0;

13-for循环

OC:

intsum =0;

for(inti =0; i <=10; i++) {

sum = i++;

}

NSLog(@”%d”, sum);

输出结果:十

intsum =0;

inti =0;

for(; i <=10; i++) {

sum = i++;

}

NSLog(@”%d”, sum);

输出结果:拾

intsum =0;

inti =0;

for(; i <=10; ) {

sum = i++;

i++;

}

NSLog(@”%d”, sum);

输出结果:拾

intsum =0;

inti =0;

for( ; ; ) {

sum = i++;

i++;

if(i >10) {

break;

}

}

NSLog(@”%d”, sum);

出口结果:10

intsum =0;

inti =0;

for( ; ; ) {

sum = i++;

i++;

NSLog(@”%d”, sum);

}

出口结果:死循环

假设唯有一条指令for后边的大括号能够回顾

for后边的五个参数都得以简单,倘使简单循环境保护持语句,那么默以为真

Swift:

0.for后的圆括号能够简轻易单

一.只可以以bool作为基准语句

2.假诺唯有条指令for前面包车型大巴大括号不得以轻巧

三.for末尾的八个参数都足以大致,假如轻松循环境保护持语句,那么暗中同意为真

varsum:Int=0

forvari =0; i <=10; i++

{

sum= i++

}

print(sum)

出口结果:拾

varsum1:Int=0

vari1 =0

for;i1<=10;i1++

{

sum1=i1++

}

print(sum1)

出口结果:十

varsum2:Int=0

vari2 =0

for;i2<=10;

{

sum2=i2++

i2++

}

print(sum2)

出口结果:10

varsum3:Int=0

vari3 =0

for; ;

{

sum3=i3++

i3++

ifi3>10

{

break

}

}

print(sum3)

输出结果:拾

for in循环**

OC:

格式: for (接收参数in收取的参数) {必要进行的言语}

for in含义:从(in)收取什么给哪些,直到取完停止

for(NSNumber*iin@[@1,@2,@3,@4,@5]) {

NSLog(@”%@”, i);

}

出口结果:

2016-01-06 17:17:38.669 OCTest[4599:1510680] 1

2016-01-06 17:17:38.670 OCTest[4599:1510680] 2

2016-01-06 17:17:38.670 OCTest[4599:1510680] 3

2016-01-06 17:17:38.670 OCTest[4599:1510680] 4

2016-01-06 17:17:38.670 OCTest[4599:1510680] 5

NSDictionary*dict =@{@”name”:@”LZH”,@”age”:@100};

for(NSArray*keysindict.allKeys) {

NSLog(@”%@”, keys);

}

出口结果:

2016-01-06 17:18:17.419 OCTest[4609:1515258] name

2016-01-06 17:18:17.420 OCTest[4609:1515258] age

NSDictionary*dict =@{@”name”:@”lzh”,@”age”:@30};

for(NSArray*keysindict.allValues) {

NSLog(@”%@”, keys);

}

输出结果:

2016-01-06 17:18:47.592 OCTest[4619:1519194] lzh

2016-01-06 17:18:47.593 OCTest[4619:1519194] 30

Swift:

for in一般用于遍历区间大概聚众

varsum4:Int=0

fori4in一…10会将距离的值依次赋值给i

{

sum4+= i4;

}

print(sum4)

出口结果:55

fordictin[“name”:”LZH”,”age”:30]

{

print(dict);

}

出口结果:

(“age”, 30)

(“name”, lzh)

for(key, value)in[“name”:”LZH”,”age”:30]

{

print(“\(key) =\(value)”)

}

出口结果:

age = 30

name = LZH


 for (; i <= 10; i++) {

 for (; i <= 10; i++) {

14-break-continue

break:跳出循环,无论循环境保护持规范是或不是还为真都不会再施行循环

continue:跳出此次巡回,假设循环境保护持标准还为真还会继续实施循环

OC:

NSArray*arr =@[@1,@3,@5,@7,@8];

for(NSNumber*numinarr) {

if([numisEqualTo:@(7)]) {

NSLog(@”找到幸运数字”);

break;

}

NSLog(@”未有找到幸运数字”);

}

输出结果:

2016-01-06 17:23:07.807 OCTest[4684:1554896]从未有过找到幸运数字

2016-01-06 17:23:07.808 OCTest[4684:1554896]并未有找到幸运数字

2016-01-06 17:23:07.808 OCTest[4684:1554896]一向不找到幸运数字

2016-01-06 17:23:07.808 OCTest[4684:1554896]找到幸运数字

NSArray *arr =@[@1,@3,@5,@7,@8];

intcount =0;

for(NSNumber *numinarr) {

if(num.intValue %2!=0) {

NSLog(@”不能被2整除”);

continue;

}

NSLog(@”能被2整除”);

count++;

}

NSLog(@”count = %d”, count);

输出结果:

2016-01-06 17:23:48.005 OCTest[4694:1560348]不能被2整除

2016-01-06 17:23:48.006 OCTest[4694:1560348]不能被2整除

2016-01-06 17:23:48.006 OCTest[4694:1560348]不能被2整除

2016-01-06 17:23:48.006 OCTest[4694:1560348]不能被2整除

2016-01-06 17:23:48.006 OCTest[4694:1560348]能被2整除

2016-01-06 17:23:48.006 OCTest[4694:1560348] count = 1

Swift:

vararr:Array = [1,3,5,7,8]

fornuminarr{

ifnum ==7

{

print(“找到幸运数字”)

break

}

print(“未有找到幸运数字”)

}

出口结果:

从没找到幸运数字

未曾找到幸运数字

不曾找到幸运数字

找到幸运数字

vararr1:Array = [1,3,5,7,8]

varcount:Int=0

fornuminarr1{

ifnum %2!=0

{

print(“不能被2整除”)

continue

}

print(“能被2整除”)

count++

}

print(“count =\(count)”)

输出结果:

不能被2整除

不能被2整除

不能被2整除

不能被2整除

能被2整除

count = 1


 sum = i++;

 sum = i++;

15- Switch

格式: switch(须求分外的值) case相称的值:要求实施的语句break;

能够穿透

能够不写default

default地点可以不管放

在case中定义变量要求加大括号,不然功用域混乱

不可能判别目的类型

OC:

charrank =’A’;

switch(rank) {

case’A’:

NSLog(@”优”);

break;

case’B’:

NSLog(@”良”);

break;

case’C’:

NSLog(@”差”);

break;

default:

NSLog(@”未有评级”);

break;

}

出口结果:

能够穿透

charrank =’A’;

switch(rank) {

case’A’:

NSLog(@”优”);

case’B’:

NSLog(@”良”);

break;

case’C’:

NSLog(@”差”);

break;

default:

NSLog(@”未有评级”);

break;

}

出口结果:

2016-01-06 20:15:41.643 OCTest[6617:1852944]优

2016-01-06 20:15:41.644 OCTest[6617:1852944]良

能够不写default**

charrank =’A’;

switch(rank) {

case’A’:

NSLog(@”优”);

break;

case’B’:

NSLog(@”良”);

break;

case’C’:

NSLog(@”差”);

break;

}

输出结果:

2016-01-06 20:16:30.171 OCTest[6629:1860297]优

default岗位能够不管放**

charrank =’E’;

switch(rank) {

default:

NSLog(@”未有评级”);

break;

case’A’:

{

intscore =100;

NSLog(@”优”);

break;

}

case’B’:

NSLog(@”良”);

break;

case’C’:

NSLog(@”差”);

break;

}

出口结果:

2016-01-06 20:17:14.444 OCTest[6639:1866501]未曾评级

case中定义变量须要加大括号,不然作用域混乱**

charrank =’A’;

switch(rank) {

case’A’:

{

intscore =100;

NSLog(@”优”);

break;

}

case’B’:

NSLog(@”良”);

break;

case’C’:

NSLog(@”差”);

break;

}

出口结果:

2016-01-06 20:17:56.849 OCTest[6649:1872272]优

无法确定目标类型

以下写法是荒唐的

NSNumber*num =@100;

switch(num) {

case@100:

NSLog(@”优”);

break;

default:

NSLog(@”未有评级”);

break;

}

Swift:

Swift:能够决断目的类型, OC必须是整数

不得以穿透

能够不写break

总得写default

default位置只可以在最后

在case中定义变量不用加大括号

varrank =”A”

switchrank{

case”A”:相当于if

print(“优”)

case”B”:相当于else if

print(“优”)

case”C”:相当于else if

print(“优”)

default:相当于else

print(“未有评级”)

}

因为不能够穿透所以不可能这么写

以下写法是漏洞百出的:

varrank1 =”A”

switchrank1{

case”A”:

case”B”:

print(“优”)

case”C”:

print(“优”)

default:

print(“没有评级”)

}

唯其如此那样写

varrank1 =”A”

switchrank1{

case”A”,”B”:注意OC无法如此写

print(“优”)

case”C”:

print(“差”)

default:

print(“未有评级”)

}

必须写default**

以下写法是漏洞百出的:

varrank2 =”A”

switchrank2{

case”A”:

print(“优”)

case”B”:

print(“良”)

case”C”:

print(“差”)

}

default职位只可以在结尾**

以下写法是不对的:

varrank3 =”A”

switchrank3{

default:

print(“没有评级”)

case”A”:

print(“优”)

case”B”:

print(“良”)

case”C”:

print(“差”)

}

case中定义变量不用加大括号**

varrank4 =”A”

switchrank4{

case”A”:

varnum =10

print(“优”)

case”B”:

print(“良”)

case”C”:

print(“差”)

default:

print(“没有评级”)

}

输出结果:

间隔和元祖相称

varnum =10;

switchnum{

case1…9:

print(“个位数”)

case10…99:

print(“十位数”)

default:

print(“其它数”)

}

出口结果:十位数

varpoint = (10,15)

switchpoint{

case(0,0):

print(“坐标在原点”)

case(一…拾,拾…20):能够在元祖中再加上区间

print(“坐标的X和Y在1~10之间”)

case(_,0):X能够是放肆数

print(“坐标的X在X轴上”)

default:

print(“Other”)

}

输出结果:坐标的X和Y在1~10之间

值绑定

varpoint = (1,10)

switchpoint{

case(varx,十):会将point中X的值赋值给X

print(“x=\(x)”)

case(varx,vary):会将point中XY的值赋值给XY

print(“x=\(x) y=\(y)”)

casevar( x, y):

print(“x=\(x) y=\(y)”)

default:

print(“Other”)

}

出口结果:

x= 1

基于条件绑定

varpoint = (100,10)

switchpoint{

只有where前面包车型客车标准表明式为真才赋值并实施case后的口舌

casevar(x, y)wherex > y:

print(“x=\(x) y=\(y)”)

default:

print(“Other”)

}

出口结果:x= 100 y= 10


 }

 }

16-函数概念

函数:

形成有个别特定义务的代码块,给代码起2个适中的名号叫做函数名称.

随后须求施行代码块只要求使用函数名称调用就可以.

好比每一个人都有3个名字,叫名字就能找到呼应的人

OC:

不带参数

– (void)say

{

NSLog(@”hello”);

}

涵盖一个参数

– (void)sayWithName:(NSString *)name

{

NSLog(@”hello %@”, name);

}

包蕴五个参数

– (void)sayWithName:(NSString *)name age:(NSInteger)age

{

NSLog(@”hello %@ , I’m %tu years old”, name, age);

}

有再次回到值

– (NSString *)info

{

return@”name = gxq, age = 30″;

}

有重临值,并且包含重返值

– (NSString *)infoWithName:(NSString *)name age:(NSInteger)age

{

return[NSString stringWithFormat:

@”name = %@,

age = %tu”, name, age];

}

swift:

格式:

func函数名称(参数名:参数类型,参数名:参数类型…)
->函数再次回到值{函数落成部分}

无参无重临值

funcsay() ->Void

{

print(“hello”)

}

say()

出口结果:hello

funcsay1()假诺未有重回值能够不写

{

print(“hello”)

}

say1()

出口结果:hello

有参无重返值

funcsayWithName(name:String)

{

print(“hello\(name)”)

}

sayWithName(“gxq”)

输出结果:hello gxq

包蕴八个参数

funcsayWithName(name:String, age:Int)

{

print(“hello\(name) , I’m\(age) years old “)

}

sayWithName(“gxq”, age:30)

出口结果:hello gxq , I’m 30 years old

无参有重临值

funcinfo() ->String

{

return”name = gaowei, age = 30″

}

print(info())

输出结果:name = gaowei, age = 30

有参有再次回到值

funcinfo(name:String, age:Int) ->String

{

return”name =\(name), age =\(age)”

}

print(info(“lzh”, age:30))

出口结果:name = lzh, age = 30

嵌套函数

vararr:Array = [“lzh”,”gaowei”,”520″]

funcshowArray(array:[String])

{

fornumberinarray

{

print(“\(number), “)

}

}

showArray(arr)

输出结果:

lzh,

gaowei,

520,

funcbubbleSort(inoutarray:[Int])

{

funcswap(inouta:Int,inoutb:Int)

{

lettemp = a

a = b

b = temp

}

letcount = array.count;

forvari =1; i < count; i++

{

forvarj =0; j < (count – i); j++

{

ifarray[j] > array[j +1]

{

swap(&array[j], b: &array[j +1])

}

}

}

}

vararr:Array = [50,20,30,80]

bubbleSort(&arr)

print(arr)

出口结果:[20, 30, 50, 80]


 NSLog(@”%d”, sum);

 NSLog(@”%d”, sum);

17- 内部函数,外部函数

里头函数:暗中认可情况下的参数都以在那之中参数

外表函数:纵然有三个参数的景况,调用者并不知道各样参数的意义,

只可以透过查看头文件的款型明白参数的意义

那就是说能否和OC同样让调用者直观的明亮参数的意义呢?使用外部参数

表面参数只好外部用,函数内部不能够运用,函数内部只可以选择个中参数

funcdivisionOpertaion1(a:Double, b:Double) ->Double{

returna / b

}

funcdivisionOpertaion2(dividend:Double, divisor:Double) ->Double{

returndividend / divisor

}

funcdivisionOpertaion3(dividend a:Double, divisor b:Double) ->Double{

returna / b

}

print(divisionOpertaion3(dividend:10, divisor:3.5))

funcdivisionOpertaion4(a:Double, divisor b:Double) ->Double{

returna / b

}

print(divisionOpertaion4(10, divisor:3.5))

输出结果:

2.85714285714286

2.85714285714286

funcdivisionOpertaion(dividend:Double, divisor:Double) ->Double{

returndividend / divisor

}

print(divisionOpertaion(10, divisor:3.5))

输出结果:2.85714285714286

暗许参数:**

能够在概念函数的时候给某些参数赋值,当外部调用未有传递该参数时会自动使用默许值

funcjoinString(s1:String,toString s2:String, jioner s3:String)
->String

{

returns1 + s3 + s2;

}

funcjoinString2(s1:String,toString

s2:String, jioner

s3:String=”❤️”) ->String

{

returns1 + s3 + s2;

}

print(joinString2(“hi”, toString:”beauty”))

出口结果:hi❤️beauty

假诺钦定了私下认可参数,不过确未有注解外部参数时

系统会自行把个中参数名称既作为内部参数也当作外部参数名称

再者在调用时一旦急需修改暗中同意参数的值必须写上国外贸大学部参数名称

funcjoinString3(s1:String,toString

s2:String,

jioner:String=”❤️”) ->String

{

returns1 + jioner + s2;

}

print(joinString3(“hi”, toString:”beauty”, jioner:”🐔”))

出口结果:hi🐔beauty

在别的语言中暗许参数智能出现在参数列表的末尾面,不过在Swift中得以出现在其余职责

funcjoinString4(s1:String,

jioner:String=”❤️”,

toString s2:String) ->String

{

returns1 + jioner + s2;

}

print(joinString4(“hi”, jioner:”🐔”, toString:”beauty”))

出口结果:hi🐔beauty

常量参数和遍历参数:

默许意况下Swift中装有函数的参数都以常量参数

1旦想在函数中期维修改参数,必须在参数前拉长var

funcswap(vara:Int,varb:Int)

{

print(“交换前a =\(a) b =\(b)”)

lettemp = a;

a = b;

b = temp;

print(“交换后a =\(a) b =\(b)”)

}

swap(10, b:20)

输出结果:

交换前a = 10 b = 20

交换后a = 20 b = 10

inout参数**

假如想在函数中期维修改外界流传的参数

能够将参数的var换来inout,那回会传送参数本身而不是参数的值

funcswap(inouta:Int,inoutb:Int)

{

lettemp = a;

a = b;

b = temp;

}

varx1 =10;

vary1 =20;

print(“交换前a =\(x1) b =\(y1)”)

swap(&x1, b: &y1)

print(“交换后a =\(x1) b =\(y1)”)

输出结果:

交换前a = 10 b = 20

交换后a = 20 b = 10

变参函数

要是未有变参函数,并且函数的参数个数又不鲜明那么只可以写多少个方法照旧用将函数参数改为集聚

变参只好放到参数列表的最终一人,变参必须内定数据类型,变参只好是同体系型的数额

funcadd(num1:Int, num2:Int, num3:Int) ->Int

{

letsum = num1 + num2 + num3

returnsum

}

print(add(1, num2:2, num3:3))

输出结果:6

funcadd(nums:[Int]) ->Int

{

varsum =0;

fornuminnums

{

sum += num

}

returnsum

}

print(add([1,2,3]))

出口结果:六

funcadd(nums:Int…) ->Int

{

varsum =0;

fornuminnums

{

sum += num

}

returnsum

}

print(add(1,2,3))

出口结果:陆

funcadd(other:Int, nums:Int…) ->Int

{

varsum =0;

fornuminnums

{

sum += num

}

returnsum

}

print(add(99, nums:1,2,3))

输出结果:6


 

 

1八- 函数类型

函数类型:

类似于C语言的针对性函数的指针

类似于OC语言的block

函数类型是由函数的参数类型和再次来到值类型组成的

那三个函数的品类是(Int, Int) -> Int

funcsum(a:Int, b:Int) ->Int

{

returna + b;

}

funcsub(a:Int, b:Int) ->Int

{

returna – b;

}

可以接纳函数类型定义函数变量和常量

varfuncP:(Int,Int) ->Int=sum

funcP=sub

print(funcP(10,20))

输出结果:-10

funcsum(a:Int, b:Int) ->Int

{

returna + b;

}

funcsub(a:Int, b:Int) ->Int

{

returna – b;

}

函数类型能够看作函数的参数

funccalFunc(a:Int, b:Int,Option:(Int,Int) ->Int) ->Int

{

returnOption(a, b)

}

print(calFunc(10, b:20, Option:sum))

print(calFunc(10, b:20, Option:sub))

输出结果:

30

-10

函数类型可以当做函数重临值

funcmax(a:Int, b:Int) ->Int

{

returna > b ? a : b

}

funcmin(a:Int, b:Int) ->Int

{

returna < b ? a : b

}

funcchooseFunc(getMax:Bool) -> (Int,Int) ->Int

{

returngetMax ?max:min

}

varfuncP2:(Int,Int) ->Int=chooseFunc(false)

print(funcP2(10,20))

出口结果:10


1玖-闭包,闭包函数回调,尾随闭包,闭包捕获值

**闭包:**

函数是闭包的壹种

类似于OC语言的block

闭包表明式(无名氏函数) –能够捕获上下文中的值

语法: in关键字的目标是有利于区分重临值和执行语句

闭包表明式的类型和函数的类型同样,是参数加上再次回到值,也正是in从前的部分

{

(参数) ->再次来到值类型in

实行语句

}

完整写法

letsay:(String) ->Void= {

(name:String) ->Voidin

print(“hi\(name)”)

}

say(“lzh”)

出口结果:hi lzh

一向不再次来到值写法

letsay:(String) ->Void= {

(name:String)in

print(“hi\(name)”)

}

say(“lzh”)

输出结果:hi lzh

未曾参数未有重临值写法

letsay:() ->Void= {

print(“hi lzh”)

}

say()

出口结果:hi lzh

闭包表明式作为回调函数

思想数组排序写法:

症结:不确定是小到大,不必然是整个相比,有希望只相比较个位数

因此,怎样比较能够交到调用者决定

funcbubbleSort(inoutarray:[Int])

{

letcount = array.count;

forvari =1; i < count; i++

{

forvarj =0; j < (count – i); j++

{

ifarray[j] > array[j +1]

{

lettemp = array[j]

array[j] = array[j +1]

array[j +1] = temp

}

}

}

}

闭包写法:

funcbubbleSort(inoutarray:[Int], cmp: (Int,Int) ->Int)

{

letcount = array.count;

forvari =1; i < count; i++

{

forvarj =0; j < (count – i); j++

{

ifcmp(array[j], array[j +1]) == -1

{

lettemp = array[j]

array[j] = array[j +1]

array[j +1] = temp

}

}

}

}

letcmp = {

(a:Int, b:Int) ->Intin

ifa > b{

return1;

}elseifa < b

{

return-1;

}else

{

return0;

}

}

vararr:Array = [31,13,52,84,5]

bubbleSort(&arr, cmp:cmp)

print(arr)

输出结果:

[84, 52, 31, 13, 5]

闭包作为参数字传送递

vararr:Array = [31,13,52,84,5]

bubbleSort(&arr, cmp: {

(a:Int, b:Int) ->Intin

ifa > b{

return1;

}elseifa < b

{

return-1;

}else

{

return0;

}

})

print(arr)

出口结果:

[84, 52, 31, 13, 5]

尾随闭包:

要是闭包是最后二个参数,能够一向将闭包写到参数列表前面

诸如此类能够抓牢阅读性.称之为尾随闭包

bubbleSort(&arr) {

(a:Int, b:Int) ->Intin

ifa > b{

return1;

}elseifa < b

{

return-1;

}else

{

return0;

}

}

闭包表达式优化

一.类型优化,由于函数中曾经宣示了闭包参数的类别

所以传入的实参能够不用写类型

二.重返值优化,同理由于函数中曾经宣示了闭包的归来值类型

据此传入的实参能够不用写类型

③.参数优化, swift能够运用$索引的不贰秘技来拜会闭包的参数,默许从0伊始

bubbleSort(&arr){

(a , b) -> Int in

(a , b) in

if$0 > $1{

return1;

}elseif$0 < $1

{

return-1;

}else

{

return0;

}

}

假使唯有一条语句能够省略return

lethehe = {

“我是lzh”

}

闭包捕获值

funcgetIncFunc() -> (Int) ->Int

{

varmax =10

funcincFunc(x :Int) ->Int{

print(“incFunc函数停止”)

max++

returnmax + x

}

当试行到这一句时inc参数就应当被释放了

而是由于在内部函数中应用到了它,所以它被捕获了

同理,当实施完这一句时max变量就被释放了

唯独由于在内部函数中采用到了它,所以它被抓获了

print(“getIncFunc函数结束”)

returnincFunc

}

被破获的值会和与之相应的方法绑定在同步

同2个格局中的变量会被绑定到不一致的点子中

letincFunc =getIncFunc()

print(“———“)

print(incFunc(5))

print(“———“)

print(incFunc(5))

出口结果:

getIncFunc函数甘休


incFunc函数截止

16


incFunc函数甘休

17

letincFunc2 =getIncFunc(5)

print(incFunc2(5))

出口结果:

getIncFunc函数甘休

incFunc函数截至

16

 int sum = 0;

 int sum = 0;

 int i = 0;

 int i = 0;

 for (; i <= 10; ) {

 for (; i <= 10; ) {

 sum = i++;

 sum = i++;

 i++;

 i++;

 }

 }

 NSLog(@”%d”, sum);

 NSLog(@”%d”, sum);

 

 

 

 

 int sum = 0;

 int sum = 0;

 int i = 0;

 int i = 0;

 for ( ; ; ) {

 for ( ; ; ) {

 sum = i++;

 sum = i++;

 i++;

 i++;

 if (i > 10) {

 if (i > 10) {

 break;

 break;

 }

 }

 }

 }

 NSLog(@”%d”, sum);

 NSLog(@”%d”, sum);

 

 

 int sum = 0;

 int sum = 0;

 int i = 0;

 int i = 0;

 for ( ; ; ) {

 for ( ; ; ) {

 sum = i++;

 sum = i++;

 i++;

 i++;

 NSLog(@”%d”, sum);

 NSLog(@”%d”, sum);

 }

 }

 借使只有一条指令for前边的大括号能够简简单单

 如若唯有一条指令for后边的大括号能够简轻巧单

 for前面的多少个参数都得以简轻巧单, 如若省略循环境保护持语句, 那么默感觉真

 for前面的几个参数都足以归纳, 假诺省略循环境保护持语句, 那么默以为真

 

 

 

 

 Swift:

 Swift:

 0.for后的圆括号能够回顾

 0.for后的圆括号能够省略

 一.只好以bool作为基准语句

 壹.只好以bool作为基准语句

 二.倘若唯有条指令for前面包车型地铁大括号不能简轻便单

 二.壹旦只有条指令for后面包车型客车大括号不能简轻易单

 叁.for前面包车型大巴八个参数都足以简简单单, 借使省略循环保持语句, 那么默感觉真

 3.for后边的八个参数都能够回顾, 假若省略循环保持语句, 那么默以为真

 

 

 */

 */

// 2.0

// 2.0

//var sum:Int = 0

//var sum:Int = 0

//for var i = 0; i <= 10 ; i++

//for var i = 0; i <= 10 ; i++

//{

//{

//    i += 1

//    i += 1

//    sum = i

//    sum = i

//}

//}

//print(sum)

//print(sum)

 

 

//var sum1:Int = 0

//var sum1:Int = 0

//var i1:Int = 0

//var i1:Int = 0

//for ; i1 <= 10 ; i1++

//for ; i1 <= 10 ; i1++

//{

//{

//    i1 += 1

//    i1 += 1

//    sum1 = i1

//    sum1 = i1

//}

//}

//print(sum1)

//print(sum1)

 

 

//var sum2:Int = 0

//var sum2:Int = 0

//var i2 = 0

//var i2 = 0

//for ;i2 <= 10;

//for ;i2 <= 10;

//{

//{

//    i2 += 1

//    i2 += 1

//    sum2 = i2

//    sum2 = i2

//}

//}

//print(sum2)

//print(sum2)

 

 

//var sum3:Int = 0

//var sum3:Int = 0

//var i3 = 0

//var i3 = 0

//for ; ;

//for ; ;

//{

//{

//    i3 += 1

//    i3 += 1

//    sum3 = i3

//    sum3 = i3

//    if i3 > 10

//    if i3 > 10

//    {

//    {

//        break

//        break

//    }

//    }

//}

//}

//print(sum3)

//print(sum3)

 

 

// 3.0 for in 代替

// 3.0 for in 代替

 

 

/*

/*

 for in循环

 for in循环

 格式: for (接收参数 in 抽取的参数) {要求实践的话语}

 格式: for (接收参数 in 抽取的参数) {必要推行的讲话}

 for in含义: 从(in)抽出什么给什么, 直到取完停止

 for in含义: 从(in)抽出什么给什么, 直到取完截至

 OC:

 OC:

 for (NSNumber *i  in @[@1, @2, @3, @4, @5]) {

 for (NSNumber *i  in @[@1, @2, @3, @4, @5]) {

 NSLog(@”%@”, i);

 NSLog(@”%@”, i);

 }

 }

 

 

 NSDictionary *dict = @{@”name”:@”lnj”, @”age”:@30};

 NSDictionary *dict = @{@”name”:@”lnj”, @”age”:@30};

 for (NSArray *keys  in dict.allKeys) {

 for (NSArray *keys  in dict.allKeys) {

 NSLog(@”%@”, keys);

 NSLog(@”%@”, keys);

 }

 }

 

 

 NSDictionary *dict = @{@”name”:@”lnj”, @”age”:@30};

 NSDictionary *dict = @{@”name”:@”lnj”, @”age”:@30};

 for (NSArray *keys  in dict.allValues) {

 for (NSArray *keys  in dict.allValues) {

 NSLog(@”%@”, keys);

 NSLog(@”%@”, keys);

 }

 }

 

 

 Swift:

 Swift:

 for in 一般用来遍历区间可能聚众

 for in 一般用来遍历区间可能聚众

 */

 */

var sum4:Int = 0

var sum4:Int = 0

for i in 一..<十 // 会将间距的值叁次赋值给i

for i in ①..<10 // 会将间隔的值一遍赋值给i

{

{

    sum4 += i

    sum4 += i

}

}

print(sum4)

print(sum4)

 

 

for dict in [“name”:”xiaohange”,”age”:23] as [String : Any]

for dict in [“name”:”xiaohange”,”age”:23] as [String : Any]

{

{

    print(dict)

    print(dict)

}

}

 

 

for (key, value) in [“name”:”hjq”, “age”:24] as [String : Any]

for (key, value) in [“name”:”hjq”, “age”:24] as [String : Any]

{

{

    print(“key = \(key) value = \(value)”)

    print(“key = \(key) value = \(value)”)

}

}

 

 

//这样就完事了对数组的遍历了, 不过还有另一个境况,
要是大家想知道每一回遍历的目录怎么办吧,还有壹种办法:

//那样就完了了对数组的遍历了, 可是还有另多个气象,
倘诺大家想清楚每一回遍历的目录如何做吧,还有一种方法:

let numberList = [1,2,3,4]

let numberList = [1,2,3,4]

 

 

for num in numberList.enumerated(){

for num in numberList.enumerated(){

    print(“\(num.offset) \(num.element)”)

    print(“\(num.offset) \(num.element)”)

}

}

 

 

for (index, item) in numberList.enumerated().reversed() {

for (index, item) in numberList.enumerated().reversed() {

    print(index,item)

    print(index,item)

}

}

 

 

//区间(Range)循环

//区间(Range)循环

var rs = “”;

var rs = “”;

for i in 0…10 {

for i in 0…10 {

    rs += “\(i)”

    rs += “\(i)”

}

}

print(rs)

print(rs)

 

 

 

 

/* — 2017.07.12 更新 */

/* — 2017.07.12 更新 */

/*4858.com , 0 ~ 50 的遍历 跨步 10

/* 0 ~ 50 的遍历 跨步 10

 此种方法也正是遍历开区间 0..<50, [0,50) 不会遍历最后3个数

 此种方法也正是遍历开区间 0..<50, [0,50) 不会遍历最终一个数

 用法常见对数组的遍历,可防范数组取值越界

 用法常见对数组的遍历,可堤防数组取值越界

 */

 */

for i in stride(from: 0, to: 50, by: 10) {

for i in stride(from: 0, to: 50, by: 10) {

    print(“i = \(i)”)

    print(“i = \(i)”)

}

}

 

 

/* 0 ~ 20  的遍历 跨步 5

/* 0 ~ 20  的遍历 跨步 5

 此种方法相当于遍历 0..<50 [0,50] 闭区间 会遍历最终2个数

 此种方法也正是遍历 0..<50 [0,50] 闭区间 会遍历最终一个数

 */

 */

for j in stride(from: 0, through: 20, by: 5) {

for j in stride(from: 0, through: 20, by: 5) {

    print(“j = \(j)”)

    print(“j = \(j)”)

}

}

 

 

/*

/*

 遍历元组 (实际跟遍历字典类似)

 遍历元组 (实际跟遍历字典类似)

 */

 */

let tupleArray = [(“zhangShang”,60,170.0),

let tupleArray = [(“zhangShang”,60,170.0),

                  (“liSi”,77,175.0),

                  (“liSi”,77,175.0),

                  (“wangWu”,80,180.0)]

                  (“wangWu”,80,180.0)]

for t in tupleArray {

for t in tupleArray {

    print(“name : \(t.0), weight : \(t.1), height : \(t.2)”)

    print(“name : \(t.0), weight : \(t.1), height : \(t.2)”)

}

}

 

 

发表评论

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

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