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

Posted 2020-08-20 深情不及久伴 ♪

//: 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("数据已在集合中")