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