当前位置: 澳门新濠3559 > 编程 > 正文

什么时变量,如果省略循环保持语句

时间:2019-11-01 10:05来源:编程
//var sum1:Int = 0 02-基本数据类型 基本数据类型 OC: 整型int intValue = 10; 浮点型double doubleValue = 10.10; float floatValue = 5.1; 长long 短short 有符号signed 无符号unsigned 各种类型的数据的取值范围在不

//var sum1:Int = 0

02-基本数据类型

基本数据类型

OC:

整型int intValue = 10;

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

长long

短short

有符号signed

无符号unsigned

各种类型的数据的取值范围在不同位的编译器下取值范围不同

Swift:注意关键字大写

整型

varintValue:Int=10

浮点型

varintValue1:Double=10.10表示64位浮点数

varintValue2:Float=9.9表示32位浮点数

如果按照长度划分,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

数据类型转换**

Swift不允许隐式类型转换,但可以使用显示类型转换(强制类型转换)

OC写法

intintValue =10;

doubledoubleValue = (double)intValue;

Swift写法:

varintValue:Int=10

vardoubleValue:Double

doubleValue=Double(intValue)

注意:Double()并不会修改intValue的值

而是通过intValue的值生成一个临时的值赋值给doubleValue

print(intValue)

print(doubleValue)


1.1 分支相关:

/*:

三目运算符

* 格式: 条件表达式 ? 取值1 : 取值2

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

* 提醒: 在Swift开发中三目运算符用得非常多

*/

let num = 7

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

/*:

可选类型(Optional)

只要看到数据类型后面有 ? !

* 含义: 可以有值也可以没有值, 只有可选类型的变量才能赋值nil

* convenience init? 返回一个可选类型的值

* 注意: 如果输出可选类型的值, 会包装一个Optional

* 如果在变量的后面加上一个!, 代表告诉系统该变量一定有值

* !称之为强制解包

*澳门新濠3559, 注意: 如果可选类型的变量中没有值, 而又进行了强制解包, 那么会引发一个运行时的错误

* 开发技巧: 作为初学者, 不要去纠结? ! ??这些符号, 初期利用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中不用对url3进行强制解包, 因为在赋值的过程中系统已经帮我们解包了

print(url3)

}

//{

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


1.5 字符串相关:

import UIKit

/*:

字符串

* OC: @""

* Swift: ""

* 特点:

1.OC中的字符串是一个对象, Swift中的字符串是一个结构体

2.Swift中的字符串的性能比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)

// 注意: Swift的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开发中字符串截取是一件非常非常非常蛋疼的问题

// 建议: 在Swift开发中如果要截取字符串, 或者以前在OC中使用的方法在Swift字符串中没有, 建议先将Swift字符串转换为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

// 3.0 for in 代替

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赋值给()中的第二个变量

// 注意: 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

//    i2 += 1

05- 可选值

使用可选类型(optionals)来处理值可能缺失的情况。

C 和 Objective-C 中并没有可选类型这个概念。

最接近的是 Objective-C 中的一个特性,

一个方法要不返回一个对象要不返回nil,nil表示“缺少一个合法的对象”

**可选值: optionals有两种状态:**

1.有值

2.没有值,没有值就是nil

?表示两种状态,一种是有值(有具体的某个值)

一种是没有值(没有代表为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)

输出结果: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)

}


1.0 if和switch分支:

{

**09-数组的批量操作**



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.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)

}

/*

18- 函数类型

函数类型:

类似于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


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

**闭包:**

函数是闭包的一种

类似于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;

}

}

闭包表达式优化

1.类型优化,由于函数中已经声明了闭包参数的类型

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

2.返回值优化,同理由于函数中已经声明了闭包的返回值类型

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

3.参数优化, 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

1.2 循环相关:

/*:

Swift中的循环和OC中的循环 "基本"一致

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: Swift开发中很少使用while

var index = 0

while index < 10

{

print(index)

index++

}

// repeat while

var i = 0

repeat{

print(i)

i++

}while(i < 10)

//print(sum3)

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);

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:表达式的结合方向是从左至右

整个表达式的值整体的值等于最后一个变量的值,简而言之就是连续赋值

写法为:

intnum1;

intnum2;

num2 = num1 =10;

NSLog(@"%d",num2);

Swift:不允许连续赋值, Swift中的整个表达式是没有值的.

主要是为了避免if (c == 9)

这种情况误写为if (c = 9) ,c = 9是一个表达式,表达式是没有值的

所以在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 = 2)

在开发中为了避免这个问题

有经验的程序员会这样写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...5

半闭区间:包含头不包含尾a..

注意: 1.Swift刚出来时的写法是a..b

2.区间只能用于整数,写小数会有问题

foriin1...5

{

print(i)

}

foriin1..<5

{

print(i)

}


--if:

/*Swift中的if和OC中的if"几乎"一模一样

* Swift中的if可以省略后面的圆括号

* OC中的if如果后面只有一条语句, 那么大括号可以省略, 而Swift中不行

* OC中的条件表达式非0即真, 而Swift中不行

* 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的位置可以随便写, 而在Swift中不允许

* 如果是在OC中default可以不用写, 而在Swift中大部分情况下是必须写的

*/

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")

}

 }

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,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,10):会将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


1.6 函数相关:

/*:

函数:

* 格式 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];

// 从Swift2.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))

未完待续...

//    sum = i

12- while循环

while循环**

OC:

格式:while(循环保持条件){需要执行的语句}

inti =0;

intsum =0;

while(i <=10) {

sum = i++;

}

NSLog(@"%d",sum);

输出结果:10

inti =0;

intsum =0;

while(i <=10)

sum = i++;

NSLog(@"%d", sum);

输出结果:10

如果只有一条指令while后面的大括号可以省略

Swift:

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

1.只能以bool作为条件语句

2.如果只有条指令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:

Swift2.0之后变为repeat while, do用于捕捉异常

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

1.只能以bool作为条件语句

2.如果只有条指令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)

输出结果:10


在学习Swift的过程中,加入与OC的对比,这样更好理解,记忆.

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

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);

输出结果:10

intsum =0;

inti =0;

for(; i <=10; ) {

sum = i++;

i++;

}

NSLog(@"%d", sum);

输出结果:10

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后的圆括号可以省略

1.只能以bool作为条件语句

2.如果只有条指令for后面的大括号不可以省略

3.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)

输出结果:10

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

fori4in1...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


{

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作为条件语句

2.如果只有条指令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("不给力")

}

输出结果:优秀


 

06-字符和字符串

字符

OC当中的字符:charcharValue ='a';

swift当中的字符:varcharValue1:Character="a"

Swift和OC字符不一样

1.Swift是用双引号

2.Swift中的字符类型和OC中的也不一样

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

而Swift中的字符除了可以存储ASCII表中的字符还可以存储unicode字符.

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

所以可以存放时间上所有国家语言的字符(大部分)

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

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

注意:双引号中只能放一个字符,如下是错误写法

varcharValue3:Character="ab"

字符串

C:

char*stringValue ="ab";

charstringArr ="ab";

OC:

NSString*stringValue ="ab";

Swift:

varstringValue1 ="ab"

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

char*stringValue ="abcbcd";

printf("%s", stringValue);

输出结果:abc

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

NSString*stringValue =@"abcbcd";

NSLog(@"%@", stringValue);

swift当中的字符串和C语言/OC语言中的字符串是不一样的

varstringValue ="abcbcd"

print(stringValue)

输入结果:abcbcd

字符串常用方法

计算字符串长度:

C:

char*stringValue ="abc李";

printf("%tu",strlen(stringValue));

输出结果:6

OC:

NSString*stringValue =@"abc李";

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

输出结果:4以UTF16计算

swift:

varstringValue ="abc李"

print(stringValue.lengthOfBytesUsingEncoding(NSUTF8StringEncoding))

输出结果:6和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!)

}


//var sum2:Int = 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

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]


//        break

04- 元组

什么是元组

在其它语言中很早就是有元组这个概念,但是对于OC程序员来说这是一个新的概念

官方定义:元组(tuples)把多个值组合成一个复合值。

元组内的值可以是任意类型,并不要求是相同类型。

将多个相同或者不同类型的值用一个小括号括起来就是一个元组

定义元组

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语言是通过传入指针或者返回结构体的方式来返回多个值的

而有了元组之后就可以实现让一个函数返回多个值


for i in 0...10 {

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:"

编辑:编程 本文来源:什么时变量,如果省略循环保持语句

关键词: