swift语言学习笔记_swift println-优快云博客

swift大小写敏感

swift输出方法println()

swift声明变量var 声明常量let 需注意 let常量只能再初始化时进行赋值，var变量可以在任何时候赋值

swift在println中输出多个变量的方法为println(“\(val1),\(val2),…”) 即在双引号中用\(var) 来输出变量

swift对数字整型有Int Int8 Int16 Int32 Int64位几种类型。其中Int会根据当前操作系统自动转换为当前系统位数的整型类型。例如当前系统是32位，则Int 实际上就是Int32

swift获取数据类型范围的方法：以Int整型为例，Int.max为获取该类型的最大值 Int.min为获取该整型的最小值

swift中如果想提高数据可读性的话，可以将1000000写成1_000_000 这样写不会影响程序的执行，又可以提高代码的可读性。

swift设置数据进制：二进制0b 八进制0o 十六进制0x

swift字符串中的转意符：\0（null字符）， \\（反斜杠），\t（制表符），\n（新行符），\r（回车符），\”（双引号），\’（单引号）

swift单字节Unicode字符，使用\xnn表示，其中nn代表两个十六进制的数

例如：

Java

1
let str ＝ “\x41″

输出为“A”

swift双字节Unicode字符，使用\unnnn表示，其中nnnn代表4个十六进制数

例如：

let str2 ＝ “\u2600″

输出为＊

swift四字节Unicode字符，使用\Unnnnnnnn表示，其中nnnnnnnn代表8个十六进制数

例如：

let str3 ＝ “\U0001F496″

输出为一个特殊字符

swift字符串大小写转换：

Objective-C

1

2

3

4

5

6

7

let small_string
= “abcd”

let big_string
= “ABCD”

println(small_string.uppercaseString)

println(big_string.lowercaseString)

如上所示，.uppercaseString为转化为大写 .lowercaseString为转化为小写

swift中的for循环写法：

Java

1
2
3
4
5
for key in value{
 
    println(key)
 
}

swift返回字符串长度：countElements(string)

swift返回字符串各字符的unicode字符编码：

Java

1

2

3

4

5

for c in string.unicodeScalars{

  print(“\(c.value)\n”)

}

swift元数组类型的操作方法：

let name = (value1,vlaue2,value3)

其中，值可以引用其他变量或常量

let (var1,var2,var3) = name

可以将之前定义的元数组中的值，赋值给声明的3个变量，并且按顺序一一对应

let (_,var2,_)=name

如果只取其中某一个，或者多个值时，不需要的的值需要用下划线代替

let name = (var1:value1,var2:value2,var3:value3)

可以在定义元数组时给元素命名，使用时只需要name.var1 调用即可。与javascript非常相似

swift中的nil通过包含另一个值或者包含nil来指明该值不存在。通过在类型后面添加问号(?)来标记一个值为可选值。例如：var value1:Int?=nil 设置一个可选值。当然，默认情况下，在表达式后加上问号将会自动为变量设定nil值，例如：var value2:Int?

但是需要注意，nil只能赋值给optional类型（即可选类型）。不能直接赋值给非可选类型，例如：var value:Int ＝ nil 这样是错误的。

可选类型的值，访问时需要再转换后的变量后加上! 才可以单独调出可选值中的内容。如下例所示：

Java

1
2
3
4
5
var str = “123″
 
var num:Int? = str.toInt()
 
var num2 = num! + 100  //输出223

demo中，将字符串str的123转换为Int数字整型，转化为成功后，变量num的实际内容为{some,123} 此时如果使用print打印的画，不会有任何问题。但是不能直接用于计算，如上例：num2中如果num后没有! 则会报错。因此这里可以理解为，带有可选值的变量后跟上一个!可以将可选值中的有效值提出，并进行计算。

swift自定义类型：

typealias ID = UInt8//自定义类型ID

var max = ID.max //查询类型ID的最大范围

var id:ID = 20; //将id变量的类型设置为ID并将值设置为20.如果超出范围会报错

swift 类型转换：

字符型String 转换为整型Int时使用 .toInt()方式。如下例子

var str_num:String = “123456″
var int_num:Int? = str_num.toInt()

将字符类型变量str_num转换为Int类型并赋值给int_num。这里需要注意的时，如果给int_num指定类型的话，必须在类型后面加上?即可选值。因为字符串不确定性很多，很多情况下转化为Int类型时会带有字符。因此需要为其设置可选值，当转换的字符串型中包含字符时，会显示nil。一般情况下如果不需要给变量指定类型的话，可以不需要加?

例如：var int_num = str_num.toInt()

其他类型转换为字符串型使用toString()的内置方法。如下例子

Java


1

2

3

4

5

var
int_num2
=
123456

 

var
str_num2
=
toString(int_num2)
 //转化为字符串”123456″

 

var
str_num3
=
toString(true)
//将布尔型转换为字符串true

运算时得数据类型转换，简单得记忆方式为，需要转换得类型(变量)。例如要转化为int16类型，则：Int16(int_num2)

如果要转化为Float类型则为：Float(int_num2)

下面列几个数据转换与计算时得一些特性，如下：

Java

1
2
3
4
5
var str:Int8 = 100
 
var str2:Int16 = 200
 
var str3:Int16 = Int16(str) + str2

str为Int8类型，str2为Int16类型。如果两个数字相加的时候，必须先将str转换为Int16格式再相加。因为swift为了避免精度的丢失，需要显式的将Int8类型转换为相同的类型。注意！这里不能将str2转换为Int8格式进行计算。

简单的记忆方法为，可以大转小，不能小转大。

Java

1

2

3

4

5

 var intNum:Int = 100

var floatNum
= 1.911

var tol
= intNum + Int(floatNum)
 //输出101

上述例子中，是一个整型与浮点型之间的运算。其中intNum为Int类型，floatNum为Double类型。如果两个类型进行相加的画，必须将其中一个类型转换为另外一个数据的类型才能正常运算。例中将floatNum转换为Int类型，转换并进行计算后结果为101。说明floatNum通过类型转换后，将小数点后的数据全部舍弃，使floatNum的值变为1。而变量tol如果不指定任何类型的画，会自动转换为右侧表达式中，正常计算的类型。

swift中空字符串的声明方式为：var str = “” 或者 var str = String() 判断字符串是否为空的属性为 .isEmpty 使用该属性后，结果以布尔型输出

swfit数组的基本语法为[value1,value2,value3,.....]

swift中数组声明时可以为数组指定类型，也可以不为数组指定类型。

如例：

var gril = ["hanmeimei",30,"teacher"]

声明的gril数组中包含字符串和数字整型，由于数组没有指定相应的内容类型，因此这样写时合法的。

而如下例：

var gril:String[] = ["hanmeimei",30,"teacher"]

声明数组时，为数组内容指定了String类型。如果这样设置的话，程序就会报错。因为其中30时整型类实数，如果一定声明类型的话，请务必将数组的内容转换为同一类型.

swift追加与删除数组元素的方法如下例：

Java

1
2
3
4
5
6
7
8
9
10
11
var gril = ["hanmeimei","30","teacher"]
 
gril.append(“china”)  //使用append方法,该方法在数组最后追加一个元素
 
gril.insert(“female”,atIndex:1)  //使用insert方法，该方法时在数组的指定位置插入一个值。0为起始位置
 
gril += ["is mother","has one children"]  //使用＋＝的形式拼接数组，拼接的内容会追加到数组的尾部
 
gril.removeAtIndex(0) //使用removeAtIndex方法，删除第0个数组元素。该方法的返回值是被删除数组元素的内容，可以将该方法赋值给一个新的变量来获取返回的内容，例如：var str = gril.removeAtIndex(0)  这时候str的值为”hanmeimei”
 
gril.count  //统计数组的元素个数

swfit中遍历数组的方法有两种：

1.for in 例如：

Java

1

2

3

4

5

for key in gril{

println(key)

}

2.有循环变量的遍历方式，可以获得数组的下标，例如：

Java

1
2
3
4
5
for (index,value) in enumerate(gril){
 
println(“下标为\(index),值为\(value)“)
 
}

此方法首先使用enumerate方法，将gril数组元素处理为元数组类型，即每次遍历都会对应(index,value)进行赋值

swift中字典的基本语法为：[key1:val1,key2:val2,key3:val3,...]

如例：

var city:Dictionary<String,String> = ["key1":"wuhan","key2":"kunming","key3":"changsha"]

创建一个city的字典，上例中为字典指定了模版，即Dictionary<String,String> 代表指定字典的key为字符串格式，val也为字符串格式。在这里为字典的key 和 val设置格式时，需要注意所属类型的范围。

city["key4"] = “guangzhuo” //向字典中追加key4 值为guangzhou

当然了，修改对应键值的内容，也可以使用这种方法，值需要为指定的键赋值即可

字典也可以使用.count属性来获取字典键值的对数

关于swift删除字典的操作方法，用下面的实例来解说：

Java

1

2

3

4

5

6

7

8

9

if let removeValue
= city.removeValueForKey(“key2″){

println(“删除的键值为\(removeValue)“)
 //打印kunimng

}else{

  println(“没有找到对应的\”key2\”的键”)

}

上述实例中，使用了removeValueForKey方法。该方法查找key2键，并将其删除，返回其键的值。其中if表达式中，先判断key2是否存在。如果key2存在，返回true，且返回被删除的键值，然后将值赋值给removeValue。

swift对字典的遍历也有两种方法，如下：

1.for in 例如：

Java

1
2
3
4
5
for (index,value) in city{
 
println(“键\(index),值\(value)“)
 
}

2.遍历键和值的方法：

Java

1

2

3

4

5

for citykey in city.keys{

println(citykey)

}

Java

1
2
3
4
5
for cityname in city.values{
 
println(cityname)
 
}

如上例，遍历key可以使用.keys属性，如果只是遍历值的话可以使用.values属性

实际上，.keys和.values两种属性还可以结合Array()函数将取出的键或值转换为数组，如下：

let cityarray = Array(city.values) //输出[changsha, guangzhuo, wuhan]

swift分支语句包含以下两种：

if else语句与其他程序一致，不做介绍。

switch语句，与其他程序有较大的区别，做了很多的优化，此处使用一个实例来说明，如下：

Java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

let number
= 12

switchnumber{

case 1,2,3,4,5,6,7,8,9,10:

  println(“1-10的数字”)

case11,12,13,14,15,16,17,18,19,20:

  println(“10-20之间的数字”)

default:

  println(“数字不在方案范围之内”)

}

 let number2
= 1_000

switch number2{

case 0 :

  println(“0″)

case 1…10:

  println(“1-10″)

case 11…100:

  println(“11-100″)

case 101…1000:

  println(“101-1000″)

case 1001…10000:

  println(“1001-10000″)

default:

  println(“不在方案范围内”)

}

通过上述两个例子，可以发现swift中的switch语句省去了每个方案的break（实际可以理解为自动加入了break并不显示），切case方案可以为任何类型的值，都可以进行判断。case支持多个值的筛选，如val1,val2,val3,… 或者值的范围筛选，如n1…n2

swift的循环语句包含四种：

1.while 语句，与其他程序语句相同，不做介绍

Java

1
2
3
4
5
6
7
8
9
var i = 0
 
while 100 > i {
 
    println(i)
 
    i++
 
}

2.do while语句

Java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

var n
= 0

do{

  println(n)

  n++

}while100>n

3.for
循环

for
var
i=0;
i<100;
i++
{

println(“数字\(i)“)

}

4.for
in
循环
主要用于遍历

//1.遍历范围

for index in 1…5{

println(index)

}

//2.忽略循环变量,仅用于计算变量，不过一般这种情况更适合用for或者while来处理

let base
= 3

let round
= 20

var point
= 1

for _ in 1…round{

  point *= base

}

println(“point是\(point)“)

//3.遍历数组

let array
=
["val1","val2","val3"]

for key in array{

println(key)

}

//4.遍历字典

var city:Dictionary<String,String>
=
["key1":"wuhan","key2":"kunming","key3":"changsha"]

for (index,value) in city{

println(“键\(index),值\(value)“)

}

//5.遍历字符串

var str2
= “swift”

for key in str2{

println(key)

}

swift跳转语句

1.continue语句

continue实例，终止当前循环，并执行下面的循环

Java

1
2
3
4
5
6
7
8
9
10
11
for var i = 0; i<100; i++ {
 
if i%10 == 0{
 
continue;
 
}
 
println(i)
 
}

2.break语句

break实例，终止当前循环，并结束剩余的循环

Java

1

2

3

4

5

6

7

8

9

10

11

for var i
= 0;
i<100;
i++
{

if i
== 10{

break;

}

println(i)

}

3.fallthrough语句

可以让switch语句中的方案选择继续贯穿下去，类似于其他语言中，case语句后没有加break的效果。

Java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
let number2 = 1_000
 
switch number2{
 
    case 0 :
 
    println(“0″)
 
    case 1…10:
 
    println(“1-10″)
 
    case 11…100:
 
    println(“11-100″)
 
    case 101…1000:
 
    println(“101-1000″)
 
    fallthrough//让方案匹配继续贯穿下去
 
    case 1001…10000:
 
    println(“1001-10000″)
 
    default:
 
    println(“不在方案范围内”)
 
}

4.return语句

一般多用于函数中的返回值所用，和其他程序基本类似，不做介绍

swift函数的定义方式，如下实例：

1.无值返回函数

Java

1

2

3

4

5

func ourput(name:String,put:String) {

println(“名字\(name),输出\(put)“)

}

2.有值返回函数

Java

1
2
3
4
5
6
7
func ourput(name:String,put:String) -> String {
 
println(“名字\(name),输出\(put)“)
 
return name+put
 
}

函数参数后面的->String是设定返回函数的类型，如果指定了类型则必须有return语句，有return语句，则必须为返回值设置类型

3.多值返回函数

Java

1

2

3

4

5

6

7

8

9

10

11

func many(in1:String,in2:String,in3:Int)
->
(set1:String,set2:String,set3:Int){

var str1
=
in1,str2
=
in2,num
=
in3

str1
+=
str2
+ String(num)

return (str1,str2,num)

}

println(many(“d1″,“d2″,3))

4.嵌套函数

Java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

//嵌套函数

func gotheway(Direction:Bool)
->
(Int)
-> Int {//返回值实际上是嵌套中的函数指针，所以还要为嵌套函数传入的参数设定类型，即(Int)

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

func goback(input:Int)
-> Int {return input
– 1}

return Direction
? goback : gofront

}

 var currentways
=
-4

let movetozero
= gotheway(currentways > 0) //由于gotheway为假，所以此时的movetozero实际上是嵌套函数中的gofront。注意，此处的gotheways只能传入布尔类型，因为这个函数只有一个布尔类型的参数。只有为函数传入对应的参数后，gotheways函数才会将嵌套的函数返回给movetozero，此时gofront才能通过movetozero这个函数指针正常工作

 whilecurrentways != 0{

  println(currentways)

  currentways = movetozero(currentways)

}