swift_简单值 | 元祖 | 流程控制 | 字符串 | 集合

//: Playground - noun: a place where people can play

import Cocoa

var str = "Hello, playground"

//这里先提及下，

//Swift中的属性的定义

//属性名首字母只能是字母，下划线

//首字母后也只能是数字，字母，下划线

/****************************************常量与变量**/

/**************常量的定义*/

//语法上就是使用let关键字

//let 124t :Int

let a2_d:Int

let stuName: String

stuName = "张三"

//stuName = "Jason"

let stuName2 = "Tom"

//stuName2 = "Sky"

/*

特点：

1、常量，value值只可以指定一次

2、常量属性可以先定义，再赋值。需要注意的是，要想先定义，再赋值，那么在定义的时候，就必须给出属性的数据类型，后面就可再赋值，这是语法上的规范

3、常量可以在定义这个常量属性的同时给它附一个值

4、也可以在定义的时候指定这个常量属性的具体数据类型，同时赋值都可以

等等.....

*/

/**************变量的定义*/

//使用var关键字来进行变量的定义

//定义一个变量属性，不指定数据类型，在定义的同时赋初始值

var stuScore = 96

//在变量上，value值是一直可以改变的

stuScore = 66

stuScore = 36

//定义一个变量属性，同时指定具体数据类型，先定义，再赋值

var status: Bool

status = false

status = true

//定义一个变量属性，先定义，再赋值

//注意，这么去写语法上是错误的

/*

var facility

facility = "sdasd"

*/

/*

特点和注意项和常量是一样的

*/

/************************************** 元祖(tuple) ****/

/***************使用let关键字定义元祖****/

/*

语法:

let tupleName = (element1,element2,element3,...)

*/

//定义一个元祖，元祖中保存多个<!!数据类型一样!!>的元素

let score = (36,58,79,80)

//访问元祖score

//通过语法tupleName.intIndex

score.0

score.1

score.2

score.3

//定义一个元祖，元祖中保存多个<!!数据类型不一样!!>的元素

let nfitStu = ("张三",19,"男",true)

//访问元祖nfitStu

//通过语法tupleName.intIndex

nfitStu.0

nfitStu.1

//定义元祖不是定义常量

//以下代码语法上严重出错

/*

let lash: Int

lash = (1,2,3)

*/

//记住语法:

//      let/var tupleName = (element1,element2,...)

//定义一个元祖，元祖中的每个元素都起一个别名

let Tom = (name: "Tom", age :21, sex :"男")

//访问元祖Tom

//在定义元祖时，元祖的每个元素都起好别名

//通过语法tupleName.elementName

Tom.name

Tom.age

Tom.sex

//定义一个元祖，可以起别名，也可以不起别名

let Jason = ("Jason",age :15,sex :"男","爬山")

//访问元祖Jason

Jason.0

Jason.1

Jason.sex

Jason.3

//当元祖中有别名的元素，也有无别名的元素

//访问元祖元素时，即可通过元祖元素索引访问

//也可通过元祖元素别名来访问

//定义一个元祖，元祖中的元素并不是都起别名，而是指定元素的数据类型

let lisiStu = (String :"lisi",Int :21,String :"男")

//这种情况下，很容易就会被弄混

//因为元祖中的元素有2个String类型的

//在访问的时候，当访问到String类型时，

//就只会访问到第一个String类型的元素

//这种情况下，就只能通过元祖元素索引来访问第二个在元祖

//中String类型的元祖元素

lisiStu.String

lisiStu.Int

lisiStu.2

/***************使用var关键字定义元祖****/

var me = ("张三",19,"男")

me.0

//使用var关键字定义元祖

//元祖中的元素是可以一直被改变的

me.0 = "李四"

me.0

me.1

me.1 = 21

me.2 = "妖"

me.0 = "Tom"

me.0

/*          以上都是定义元祖的同时在元祖中给每个元组指定value值*/

//元祖先定义，在赋值

let Jack :(name :String,age :Int,sex :String) = ("jack",12,"魔")

/*

其他特点和let关键字是一样的

区别就只是

let关键字定义定义的元祖的元素value值只可以接受一次

var关键字定义的元祖的元素value之可以一直被改变

元祖定义语法

1> let/var tupleName = (element1,element2,element_N)

2> let/var tupleName = (type1Element, type2Element, N)

3> let/var tupleName = (elementName1: value, elementName2:value,..N)

4> let/var tupleName = (type1: value, type2: value,...N)

5> let/var tupleName: (type1,type2) = (type1Value, type2Value)

6> let/var tupleName: (elementName1 :type, elementName2 :type) = (elmentName1_value, elmentName2_value)

7> let/var tupleName: (type1,type2) = (elementName1: value, elementName2: value)

(语法7,由于在定义元祖时只指定了元素类型,后面赋值时才给定的元素别名，所以访问时也只能通过索引来访问)

(语法1> 2> 3> 4>可以混搭)

*/

/**************************** swift中的字符串 ******/

//语法上也是用let/var关键字

//let是常态属性，var是可变属性

/*********************** 定义属性的3种语法  */

//定义第一个字符串

//定义的同时赋值，但不指定具体数据类型

let str1 = "abcdefghij"

//定义第二个字符串

//定义的同时赋值，指定具体的数据类型

let str2 :String = "Hello World"

//定义第三个字符串

//先定义，再赋值

//注意，在定义该属性时就必须给出数据类型

let str3 :String

str3 = "张三"

//言归正传，回到String类型[字符串的练习]

//定义字符串str4

let str4 :String

str4 = "Hello"

//定义字符串str5

let str5 = " World!"

//在Swift中的字符串是可以拼接在一起的

//语法上使用 + 这个符号

//将str4和str5两个字符串拼接在一起

let str6 :String = str4+str5

//PS swift拼接字符串，不可以使用+=运算符将两个字符串属性拼接，这是错误语法

//使用 += 运算符来将字符串拼接在一起，该属性必须是可变的

//正确语法:

var str7 = "abc"

str7 += "def"

//回想一下，在JavaScript中，没有常量可言，定义的属性都是可变的

//也是使用var关键字来定义

//************************************ swift_String(字符串)中的常用方法

//定义字符串str8

var str8 :String

str8 = "abcdefg"

//获取str8字符串的长度

str8.characters.count

//str8[1]

//若要操作[访问]字符串

/*

注意，这里不是Java，也不是c#

*/

//这里是Swift，所以，以往学习的语言中，访问字符串的方式在这里就用不上了

//在Swift中访问String字符串，

//使用 startIndex[获取字符串的第一个字符的索引下标]

// 和 endIndex[获取字符串的最后一个字符的索引下标]

//配合方法 index[获取字符串中某个字符的索引下标]

//配合方法 subString 来截取字符串中的某一个字符片段

//************************************* 获取字符串字符下标索引

//定义str9字符串

let str9 = "abcdefghijklmnopq"

//获取str9字符串的长度

let str9Lenght :Int = str9.characters.count

//获取str9字符串的首字符的下标索引

let str9StartIndex = str9.startIndex

//获取str9字符串的末尾字符的下标索引

let str9EndIndex = str9.endIndex

//************************************* 截取字符串

//现有一要求，要获取出 fgh 这一个字符片段

//获取f字符所在下标位置

str9.index(str9StartIndex, offsetBy:5)

//获取h字符所在下标位置

str9.index(str9EndIndex, offsetBy: -14)

//调用subString方法来截取出str9字符串中的 fgh 这个字符片段

str9.substring(from :str9.index(str9StartIndex, offsetBy:5)).substring(to: str9.index(str9EndIndex, offsetBy: -14))

//************************************ 字符串大小写装换

//全大写

str9.uppercased()

let str10 :String

str10 = "ABCDEFG"

//全小写

str10.lowercased()

//首字母大写

str10.capitalized

//************************************ 判断是否存在

//是否有该前缀

str10.hasPrefix("AB")

str10.hasPrefix("ab")

//是否有该后缀

str10.hasSuffix("FG")

str10.hasSuffix("fg")

//是否包含

str10.contains("CE")

str10.contains("CD")

//*********************************** 嵌入

let i :Float

i = 5.5

i

let str11 = "abc \(i * 5)"

//在Java中，字符串的嵌入是使用 "+ +"

//swift中，则使用 \( )

//非常方便

//*********************************** 流程控制的练习

//用作判断条件的有

/*

1>

if(){

}else if(){

}else{

}

2>

switch(){

case_1:

case_2:

case_N:

...

default:

}

*/

//用作循环遍历的有

/*

1>

for[旧版本的语法：

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

i++

}

]

新版本新语法:

for in on...off{

}

2>

for-in {

}

3>

while{

}

4>

do-while[swift旧版本的语法]

新版本新语法：

repeat{

}while

*/

//***if - else if - else

//定义一个变量

let str12 = "abcdef"

//判断str12中是否包含cd

if (str12.contains("cd")){

print("str12中包含字符片段'cd'")

}else{

print("不包含")

}

//多层判断

if (str12.hasPrefix("cd")){

print("有这个前缀")

}else if(str12.hasSuffix("ef")){

print("有这个后缀")

}else if(str12.contains("ce")){

print("包含‘ce’这个字符片段")

}else{

print("结束")

}

/*

Swift中的多分支条件判断语句，

和Java中一样的，

只要有一个条件分支成立，

if - else if - else语句就结束了

*/

//********************* switch

//定义一个常量属性

let age = 35

/*

错误的语法:

switch age{

case 25:

print("ok")

case 16:

print("ok")

}

在swift中，

switch语句必须要有一个默认分支

*/

//正确语法

switch age{

case 25:

print("ok")

default:

print("没错，就是这个")

}

//*********************** for - in no...off

let arrs = [1,5,8,10,16,20,33]

var max = arrs[0]

for arr in 0...5 {

if arr % 2 != 0 && arr > max{

max = arr

}

}

//升序

var start = 0

for arr in arrs{

if arr > start {

start += arr

}

}

//*********************** for - in

//定义一个数组

let score2 = [90,20,33,67,89,46,70,80]

//循环遍历数组score2

for score in score2 {

print(score)

}

/*

swift中的for-in循环和Java中的for-each循环的用法是一样的

*/

//********************** while

/*

swift的while循环和Java中的while循环也是一样的，没有区别

同样是给一个条件

条件成立，则进入循环

反之，跳过

*/

var n = 3

while n<10 {

n+=1

print(n)

}

n=3

repeat{

print("XXX")

n+=1

}while n<10

/****************** 集合 Array Dictionary Set  *******************/

//************************************ Array类型的集合

let arr2 :Array<Int> = Array<Int>()

var arr3 = [1,2,3,4]

let arr4: Array<Int> = []

arr3[0]

//追加一个元素

arr3.append(5)

//往数组中追加一个数组段在数组的后面

arr3.append(contentsOf: [6,7,8])

arr3

arr3 += [10,11]

arr3.insert(contentsOf: [9,0,9], at: 2)

arr3.remove(at: 9)

arr3

//定义一个Array类型的集合

var arr5 :Array<String>

arr5 = ["张三","李四","王五","赵六"]

arr5.append(contentsOf: ["田七"])

arr5+=["郭八","周九"]

arr5.remove(at: 4)

arr5.remove(at: 3)

arr5.remove(at: 2)

arr5

//插入元素

arr5.insert(contentsOf: ["王五","赵六","田七"], at: 2)

/*

Swift中的这个Array的类型的集合类似Java中的List接口类型的集合

定义集合

操作集合

大致意思是一样的

语法上有些许差异

*/

//******************************************** Dictionary类型的集合

//定义一个Dictionary类型的集合

var dic :Dictionary = ["name":"张三","age":"21","sex":"男"]

dic["name"]

dic["age"]

dic["sex"]

/*

swift中的Dictionary类型的集合提供了两个常用的属性

Keys属性可以拿到Dictionary集合中的所有的键

Values属性可以拿到Dictionary集合中的所有的值

*/

//获取dic集合中的所有的键

for k in dic.keys{

print(k)

}

//获取dic集合中所有的value值

for v in dic.values{

print(v)

}

//循环遍历这个Dictionary集合dic

for (k,v) in dic{

print("Key is \(k), Value is \(v).")

}

/*

完毕

可以很清楚的看到，Swift中的Dictionary类型的集合类似Java中的Map集合

一个key 一个value

一个key 一个value

存数据，有集合，不用怕

Dictionary集合让你存数据方便

Dictionary这个了类型的集合就是键值对的来存取数据的

*/

//******************************************************** Set

//定义一个Set集合

var set1 :Set<String>

set1 = ["张三","李四","王五"]

//获取这个集合的长度

set1.count

//插入东西到一个Set集合中

set1.insert("赵六")

set1

//定义第二个Set集合

var set2 :Set<String>

set2 = ["田七","郭八","周九"]

/*

将第二个Set集合插入到第一个Set集合中

调用两个方法

intersection方法可以理解成为是一个一个缓冲区

所以调用这个方法的时候，数据并没有真正的到第一个Set集合中

而调用union方法时，数据才会真正的到第一个Set集合中

*/

print("预备")

set1.intersection(set2)

//在这之间，可以做些其他的事情

print("数据在缓冲区中")

set1.union(set2)

print("数据已在集合中")