常用语法1，数组的骨干选用
/*
/*
01-常量与变量
读书swift第二步打字与印刷Hello World
print(“Hello World”)
swift是毫不加分号的
何以是常量?
常量是在程序运转进程中不能够更动值的量
怎么着时变量?
变量是能够在程序运转进度中连连调换的量
在swift其中常量和变量必须在使用前声称
用let来声称常量，用var来声称变量
常量定义情势:
能够用此外你欣赏的字符作为常量和变量名，包含Unicode字符
常量与变量名不可能包罗以下:
数学符号，箭头，保留的（可能私下的）Unicode码位，连线与制表符。
也无法以数字初阶，不过能够在常量与变量名的任哪个地点方含有数字。
留神:斯威夫特中的常量必须在概念时伊始化(OC能够不开端化),不然会报错
letmax=10
let🐶=100
变量定义形式:
在OC当中先定义再开首化————>(以下为OC写法)
intage;
age =10;
也得以定义的同时开首化
intage =10;
在swift在这之中先定义再开头化:
varage 那种写法会直接报错.
报错原因:(type annotation missing in pattern:未有点名数据类型)
在Swift中只要想要先定义一个变量,
从此今后使用时再开始化必须在概念时报告编写翻译器变量的品类(类型标注)
写法为:
varage:Int
age = 20
概念的还要先河化:
在斯维夫特中壹旦定义的同时开始化3个变量,能够不用写数据类型
编写翻译期会依据开始化的值自动测算出变量的品类(项目推测机制)
varage:Int=20
varage =20
/*
break: 跳出循环, 无论循环境保护持规范是或不是还为真都不会再试行循环
break: 跳出循环, 无论循环境保护持标准是或不是还为真都不会再施行循环
0二-基本数据类型
主导数据类型
OC:
整型int intValue = 10;
浮点型double doubleValue = 10.10; float floatValue = 5.1;
长long
短short
有符号signed
无符号unsigned
各种类型的数额的取值范围在分裂位的编译器下取值范围分化
Swift:注意关键字大写
整型
varintValue:Int=10
浮点型
varintValue1:Double=10.⑩象征6三个人浮点数
varintValue二:Float=九.玖意味着30个人浮点数
借使根据长度划分,斯威夫特中的长短比OC尤其标准
varintValue3:Int8=6
varintValue4:Int16=7
varintValue5:Int32=8
varintValue6:Int64=9
有暗记无符号,私下认可是有暗号的(UInt8/UInt16/UInt32/UInt6四)
varuintValue7:UInt=10
留意:无符号的数比有暗记的取值范围越来越大,因为符号位也用来存值
斯威夫特是项目安全的言语,假若取值错误会直接报错,而OC不会
取值不对
OC:unsignedintintValue = -10;不会报错
Swift:varintValue:UInt= -10会报错
溢出:
OC:intintValue =INT_MAX+一;不会报错
Swift:varintValue:UInt=UInt.max +1会报错
数据类型的互相赋值(隐式类型调换)
OC能够隐式类型转变
intintValue =10;
doubledoubleValue = intValue;
斯威夫特:不具备隐式类型转变
在斯威夫特中“值恒久不会被隐式调换为别的门类”(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的值生成1个一时的值赋值给doubleValue
print(intValue)
print(doubleValue)
数组定义:
continue: 跳出本次巡回, 如若循环境保护持标准还为真还会继续实行循环
continue: 跳出此次巡回, 假如循环境保护持规范还为真还会继续施行循环
03- 运算符
算术运算符:
+ – * / % ++ —
除了取模,其余和OC一样,包罗预先级
varresult =10+10
result =10*10
result =10-10
result =10/10
print(result)
注意:Swift是安枕无忧严厉的编制程序语言,会在编译时候检查是不是溢出
然则只会检讨字面量而不会检讨变量
因而在Swift中毫无疑问要小心隐式溢出
遇到那种主题材料能够利用溢出运算符化解该难题:
http://www.yiibai.com/swift/overflow\_operators.html
取模%
OC:只好对整数取模
NSLog(@”%tu”,10%3);
斯维夫特:协助小数取模
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:表达式的结缘方向是从左至右
全部表明式的值全部的值等于最后三个变量的值,简单来说便是连连赋值
写法为:
intnum1;
intnum2;
num2 = num1 =10;
NSLog(@”%d”,num2);
Swift:不容许一而再赋值, 斯威夫特中的整个表达式是平素不值的.
主若是为着制止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(2 == isOpen)来制止那些难题.
在Swift中很好的消除了那么些标题
逻辑运算符在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举个例子: 1…五
半闭距离:包罗头不带有尾a..
在意: 一.Swift刚出去时的写法是a..b
2.区间只好用来整数,写小数会有标题
foriin1…5
{
print(i)
}
foriin1..<5
{
print(i)
}
OC:
04- 元组
怎样是元组
在其他语言中很已经是有元组那么些概念,可是对于OC技师来讲那是一个新的定义
合法概念:元组（tuples）把五个值组合成3个复合值。
元组内的值能够是即兴档期的顺序，并不须求是均等等级次序。
将三个1律也许差异类其他值用一个小括号括起来便是三个元组
概念元组
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)
如果不爱慕元组中的有些值能够动用_通配符来忽略提取
letstudent = (“lzh”,10,20)
let(name , age ,_) = student
print(name)
print(age)
在此前未有元组之前C和OC语言是由此传播指针大概重回结构体的章程来回到多个值的
而有了元组之后就足以兑现让三个函数重临八个值
有值数组
OC:
OC:
05- 可选值
使用可选类型（optionals）来管理值或者缺点和失误的气象。
C 和 Objective-C 中并不曾可选类型那个概念。
最相近的是 Objective-C 中的一个风味，
贰个方法要不回去3个目的要不回去nil，nil表示“贫乏四个官方的靶子”
**可选值: optionals有二种景况:**
1.有值
二.未有值,未有值便是nil
?表示三种情况,壹种是有值(有具体的有个别值)
1种是未有值(未有代表为nil)
当为?修饰时,注明这几个变量有非常的大恐怕为nil
有值
varoptValue:Int? =9
没有值
varoptValue:Int?
varoptValue:Int? =nil
**可选值能够动用if语句来开始展览推断**
4858.com，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)
输出结果:9
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)
}
NSArray *arr0 = @[@1, @2, @3];
NSArray *arr = @[@1,@3, @5, @7, @8];
NSArray *arr = @[@1,@3, @5, @7, @8];
0六-字符和字符串
字符
OC个中的字符:charcharValue =’a’;
swift当中的字符:varcharValue一:Character=”a”
Swift和OC字符不平等
一.Swift是用双引号
二.斯维夫特中的字符类型和OC中的也差异样
OC中的字符占八个字节,因为它只含有ASCII表中的字符
而斯威夫特中的字符除了能够积累ASCII表中的字符还足以存储unicode字符.
OC的字符是服从ASCII规范的,Swift的字符是遵循unicode规范的
从而能够存放时间上存有国家语言的字符(当先3/6)
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));
输出结果:6
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([常用语法1，数组的骨干选用。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!)
}
NSArray *arr1 = [NSArray arrayWithObjects:@1, @2, @3, nil];
for (NSNumber *num in arr) {
for (NSNumber *num in arr) {
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]
NSLog(@”%@”, arr1);
if ([num isEqualTo:@(7)]) {
if ([num isEqualTo:@(7)]) {
08-数组操作
获得长度
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)
出口结果:3
判断是还是不是为空
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,纵然删除了容积仍旧存在,体积是2的倍数
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
NSLog(@”找到幸运数字”);
NSLog(@”找到幸运数字”);
**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
空数组
break;
break;
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重临3个可选类型
假设字典中不设有须求立异的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
NSArray *arr2 = @[];
}
}
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后的圆括号能够回顾
1.只能以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(“不给力”)
}
输出结果:优秀
NSArray *arr3 = [NSArray array];
NSLog(@”未有找到幸运数字”);
NSLog(@”未有找到幸运数字”);
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后的圆括号能够总结
1.只可以以bool作为条件语句
二.假如唯有条指令while前面的大括号不能大致
vari:Int=0
varsum:Int=0
while(i<=10)
{
sum=i++
}
print(“\(sum)”)
输出结果:拾
vari1:Int=0
varsum1:Int=0
whilei1<=10
{
sum1=i1++
}
print(“\(sum1)”)
输出结果:十
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);
出口结果:十
借使唯有一条指令while前面包车型客车大括号能够总结
swift:
Swift2.0从此成为repeat while, do用于捕捉格外
0.while后的圆括号能够回顾
一.只可以以bool作为条件语句
二.一旦唯有条指令do前边的大括号不可能大致
vari2:Int=0
varsum2:Int=0
repeat{
sum2=i2++;
}while(i2<=10)
print(sum2)
输出结果:10
vari3:Int=0
varsum3:Int=0
repeat{
sum3=i3++;
}whilei3<=10
print(sum3)
输出结果:拾
NSLog(@”%@”, arr3);
}
}
13-for循环
OC:
intsum =0;
for(inti =0; i <=10; i++) {
sum = i++;
}
NSLog(@”%d”, sum);
输出结果:10
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作为标准语句
二.就算唯有条指令for前面的大括号不得以简轻巧单
三.for末尾的八个参数都得以归纳,借使简单循环境保护持语句,那么默以为真
varsum:Int=0
forvari =0; i <=10; i++
{
sum= i++
}
print(sum)
出口结果:10
varsum1:Int=0
vari1 =0
for;i1<=10;i1++
{
sum1=i1++
}
print(sum1)
输出结果:10
varsum2:Int=0
vari2 =0
for;i2<=10;
{
sum2=i2++
i2++
}
print(sum2)
输出结果:⑩
varsum3:Int=0
vari3 =0
for; ;
{
sum3=i3++
i3++
ifi3>10
{
break
}
}
print(sum3)
输出结果:10
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
fori四in一…拾会将间隔的值依次赋值给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
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
不可变数组:NSArray
NSArray *arr = @[@1,@3, @5, @7, @8];
NSArray *arr = @[@1,@3, @5, @7, @8];
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(1…十,10…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
可变数组:NSMutableArray
int count = 0;
int count = 0;
16-函数概念
函数:
完了有些特定职分的代码块,给代码起贰个适度的名目叫作函数名称.
然后需求施行代码块只须求动用函数名称调用就可以.
好比种种人都有二个名字,叫名字就能找到呼应的人
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
funcsay一()如若未有重临值能够不写
{
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]
*/
for (NSNumber *num in arr) {
for (NSNumber *num in arr) {
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
常量参数和遍历参数:
暗中同意情形下斯威夫特中持有函数的参数都以常量参数
假定想在函数中期维修改参数,必须在参数前增加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参数**
万1想在函数中期维修改外界盛传的参数
能够将参数的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))
出口结果:陆
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))
出口结果:陆
if (num.intValue % 2 != 0 ) {
if (num.intValue % 2 != 0 ) {
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
实施语句
}
1体化写法
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;
}
}
闭包表达式优化
1.类型优化,由于函数中一度宣称了闭包参数的体系
故而传入的实参能够不用写类型
二.重返值优化,同理由于函数中已经宣称了闭包的归来值类型
就此传入的实参可以不用写类型
三.参数优化, 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
}
被擒获的值会和与之相应的法门绑定在共同
同三个主意中的变量会被绑定到不相同的艺术中
letincFunc =getIncFunc()
print(“———“)
print(incFunc(5))
print(“———“)
print(incFunc(5))
出口结果:
getIncFunc函数截止
incFunc函数甘休
16
incFunc函数甘休
17
letincFunc2 =getIncFunc(5)
print(incFunc2(5))
输出结果:
getIncFunc函数甘休
incFunc函数结束
16
//有值数组
NSLog(@”不能被2整除”);
NSLog(@”不能被2整除”);
var arr0 = [1,2,3]
continue;
continue;
var arr1: Array = [1,2,3]
}
}
var arr2: Array<Int> = [1,2,3]
NSLog(@”能被2整除”);
NSLog(@”能被2整除”);
var arr3: [Int] = [1,2,3]
count++;
count++;
// var arr4: Int[] = [1,2,3] // 早期写法 已甩掉
}
}
NSLog(@”count = %d”, count);
NSLog(@”count = %d”, count);
//空数组
*/
*/
//var arr5 = [] // 已废弃
var arr6 = [Int]()
var arr:Array<Int> = [1,2,3,4,5,6]
var arr:Array<Int> = [1,2,3,4,5,6]
var arr7 = Array<Int>()
for num in arr{
for num in arr{
print(arr7)
if num == 7
if num == 7
{
{
//不可变数组
print(“找到你了”)
print(“找到您了”)
let arr8 : [Int] = []
break
break
//可变数组
}
}
var arr9 : [String] = [String]()
print(“未有找到”)
print(“未有找到”)
}
}
/*
成分类型
var arr1:Array<Int> = [1,2,3,4,5,6,7,8]
var arr1:Array<Int> = [1,2,3,4,5,6,7,8]
OC:
var count:Int = 0
var count:Int = 0
NSArray *arr = @[@1, @”lnj”, @1.75];
for num in arr1{
for num in arr1{
NSLog(@”%@”, arr);
if num % 2 != 0
if num % 2 != 0
*/
{
{
var arr10 = [1,”hjq”,1.65] as [Any]
print(“不能被2整除”)
print(“不能被2整除”)
print(arr10)
continue
continue
print(arr10[2])
}
}
// 打字与印刷结果: [1, “hjq”, 1.6499999999999999]
print(“能被2整除”)
print(“能被2整除”)
// 1.65
count += 1
count += 1
}
}
//借使想明显表示数组中存放的是例外类型的数额, 能够运用Any关键字,
表示数组中得以存放不相同门类的多少
print(“count = \(count)”)
print(“count = \(count)”)
var arr11:Array<Any> = [1,”hjq”,1.75]
print(arr11)
print(arr11[2])
// 打字与印刷结果: [1, “hjq”, 1.75]
// 1.75
/*
数组操作
一.获得长度
OC:
NSArray *arr = @[@1, @2, @3];
NSLog(@”%tu”, arr.count);
*/
var arr12 = [1,2,3]
print(arr12.count)
/*
贰.决断是还是不是为空
OC:
NSArray *arr = @[];
NSLog(@”%d”, arr.count != 0);
*/
var arr13 = [1,2,3]
print(arr13.isEmpty)
/*
3.检索
OC:
NSArray *arr = @[@1, @2, @3];
NSLog(@”%@”, arr[0]);
*/
var arr14 = [1,2,3,4]
print(arr14[0])
/*
4.追加
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr addObject:@4];
NSLog(@”%@”, arr);
*/
var arr15 = [1,2,3]
arr15.append(4)
print(arr15)
var arr16 = [1,2,3]
arr16 += [4]
print(arr16)
arr16 += arr16[0…1] // 也得以依附本人数组成分追加
print(arr16)
/*
5.插入
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr insertObject:@4 atIndex:0];
NSLog(@”%@”, arr);
*/
var arr17 = [1,2,3]
arr17.insert(4, at: 0)
print(arr17)
/*
6.更新
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
arr[0] = @8;
NSLog(@”%@”, arr);
*/
var arr18 = [1,2,3]
arr18[0] = 0
print(arr18)
/*
7.删除
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr removeObject:@1];
NSLog(@”%@”, arr);
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr removeLastObject];
NSLog(@”%@”, arr);
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr removeAllObjects];
NSLog(@”%@”, arr);
*/
var arr19 = [1,2,3]
arr19.remove(at: 0)
print(arr19)
var arr20 = [1,2,3,4]
arr20.removeLast()
print(arr20)
var arr21 = [1,2,3,4]
arr21.removeFirst()
print(arr21)
var arr22 = [1,2,3,4]
arr2贰.removeAll(keepingCapacity: true) // 是不是保持体积, 假使为true,
就算去除了体积依然留存, 容积是二的倍数
print(arr22)
print(arr22.capacity)
//注意: 尽管数组是3个不足变数组不能立异/插入和删除
//第3个版本的不行变数组是足以修改的
/*
Range
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
[arr removeObjectsInRange:NSMakeRange(0, 2)];
NSLog(@”%@”, arr);
*/
//移除某区间地点的数组成分
var arr23 = [1,2,3]
//arr22.removeRange(Range(start: 0, end: 1)) 2.0写法 已废弃
arr23.removeSubrange(0…1)
print(arr23)
var arr24 = [1,2,3]
arr24.replaceSubrange(0..<1, with: [8])
print(arr24)
// 其实Range就是半闭距离
var range = 0…5
//range = 9玖 // 透过报错能够想见出类型
print(range) // 通过答应也足以推论出类型
/// 那个知识点要求再追究二遍 range
//var range1:Range<Int> = 0…5
//var range二:Range<String>; // 必须信守ForwardIndexType协议
// start 起点 end 终点
//var range3:Range<Int> = Range(start: 0, end: 5)
//var range4:Range<Int> = 0..<5
//print(range3)
//print(range4)
/*
数组的批量操作
OC:
NSMutableArray *arr = [NSMutableArray arrayWithObjects:@1, @2, @3,
nil];
NSRange range = NSMakeRange(0, 2);
// [arr replaceObjectsInRange:range withObjectsFromArray:@[@99,
@88]];
[arr replaceObjectsInRange:range withObjectsFromArray:@[@99, @88,
@77, @66]];
NSLog(@”%@”, arr);
*/
var arr = [1,2,3]
//arr[0…1] = [99,98]
//arr[0…1] = [99,88,77]
//等价于上1行代码
arr.replaceSubrange(0…1, with: [99,88,77])
print(arr)
/*
4.遍历
OC:
NSArray *arr = @[@1, @2, @3];
for (int i = 0; i < arr.count; i++) {
NSLog(@”%@”, arr[i]);
}
for (NSNumber *number in arr) {
NSLog(@”%@”, number);
}
*/
var arr1 = [1,2,3]
// 2.0
//for var i = 0 ; i < arr1.count ; i++
//{
// print(arr1[i])
//}
// 3.0
for i in 0..<arr1.count
{
print(arr1[i])
}
for number in arr1
{
print(number)
}
//抽出数组中某些区间范围的值
var arr2 = [1,2,3]
for number in arr2[0..<3]
{
print(number)
}