变量和常量

字符串

数组

字典

空格

元组

分支结构

枚举

函数

demo截图

/*
 注意：在创建swift工程时，工程名不能与swift重名，因为当创建swift工程时，Xcode会自动导入swift类，一旦重名，Xcode将会找不到swift类库，导致工程出错
*/
import Foundation// 当需要导入类库时，使用import加类库名，不用再加< >和" "

// 在swift中，语句末尾可以不加";"
print("hi")
// 但是，当在同一行书写多条语句时，必须用;隔开
print("Hello");print("World")

// MARK:------------swift中的变量和常量---------------------
/*
 用let修饰常量：常量的值不可以改变
 用var修饰变量：变量的值可以改变
 注意：可以使用汉字、表情对常量、变量进行命名
*/
// 定义常量
let 常量 = "hello"
print(常量)

let a = 1.333
print(a)

let 😂 = 1
print(😂)

let 😢 = "😊"
print(😢)

let _123 = 2
print(_123)

// 定义变量
var 变量 = "OC"
变量 = "swift"// 变量的值可以修改
print(变量)
// 在swift中，如果开始没有给数据类型，swift会根据处置自动判断数据类型
// 常量、变量的数据类型
let c:Int = 8// 整形
let d:Float = 1.2// 单精度浮点型
let e:Double = 2.22// 双精度浮点型
let f:String = "String"// 字符串类型，是有序集合，可以看成Character类型的集合
let g:Character = "a"// 单个字符(使用双引号)
let flag:Bool = true// 布尔类型，值只有true、false

// 数据类型的转换：值永远不会被隐示转换为其他类型，如需转换，请写明
let h = String(d)

// 可选类型："?"表示可选类型
// 赋初值：如果使用let修饰可选类型，赋初值
let second:String? = "String"
// 不赋初值：如果使用var修饰可选类型，可不赋初值
var first:String? = "String"

// MARK:---------------swift中的字符串---------------------
// 定义字符串变量
var str1 = "hello"
// 创建空变量字符串，以下两者均为空字符串，且等价
var empty_str1 = ""
var empty_str2 = String()

// 通过字符串对象的方法 isEmpty 方法判断字符串是否为空
if(empty_str1.isEmpty)
{
    print("empty_str1 is empty")
}

// 字符串拼接
// 创建字符串变量
var str2 = "http://"
str2 += "www.baidu.com"
print(str2)

// 获取字符串长度
let count_str = " hello"
// 获取长度 ".characters.count"单个字符的个数
let length = count_str.characters.count
print(length)

// 字符串比较
let name1 = "老王"
let name2 = "隔壁"
if name1 == name2
{
    print("equal")
}
else
{
    print("\(name1) notequals \(name2)")
}

// 字符串的插值
let num = 3.0
let NewNum = "\(num) * 2.5 = \(num * 2.5)"
print(NewNum)

// MARK:-----------------swift中的数组---------------------
/*
 swift数组中，存储的数据类型都必须是同一数据类型，如果想存储不同数据类型，可以使用OC中的数组
 在swift中，使用let和var声明一个数组
 数组需要指定类型，如果没有指定，那么会根据数组的处置去推断数据类型
*/
// 定义数组
// 未给定数据类型
let nameArray:Array = ["尼古拉斯凯奇", "金凯瑞", "奥黛丽本"];// 根据初值自动判断数据类型
let genderArray = ["男", "男", "女"];

// 数组元素的访问
print(nameArray[0])
print("元素1 = ", nameArray[0])
print("元素2 = ", nameArray[1])

// 给定数据类型
var ageArray:Array<Int> = [1, 2, 3]
print(ageArray)

// 给定类型的空数组
let array = Array<String>()// 定义一个字符串类型的空数组
let _array = [String]()// 定义一个字符串类型的空数组

// 向数组中添加元素
// 方法一：
ageArray.append(4)
print(ageArray)
// 方法二：使用运算符重载数组中添加元素
ageArray += [5 ,6]
print(ageArray)

// 向数组中某个位置插入元素
ageArray.insert(7, atIndex: 2)
print(ageArray)

// 移除数组中第一个元素
ageArray.removeFirst()
print(ageArray)

// 移除数组中最后一个元素
ageArray.removeLast()
print(ageArray)

// 移除数组中某个位置的元素
ageArray.removeAtIndex(3)

// MARK:-----------------swift中的字典---------------------
/*
 字典中所有的key和value的值必须是同一数据类型
*/
// 定义字典
let let_Dic:Dictionary = ["":10]// 不可变字典
print(let_Dic)

var var_Dic:Dictionary<String, Int> = ["b":12]
print(var_Dic)

// 定义空字典
var let_empty_Dic:Dictionary<String, Int> = [:]
print(let_empty_Dic)
var var_empty_Dic:Dictionary<String, Int> = [:]
print(var_empty_Dic)

// 向字典中添加一对键值对
let_empty_Dic["c"] = 20
print(let_empty_Dic)
var_Dic["c"] = 20
print(var_Dic)

var var_Empty:Dictionary<String, Int> = [:]
var_empty_Dic["d"] = 15
print(var_Empty)

// 修改字典中的一对键值
var_Empty["d"] = 2
print(var_Empty)

// 通过key删除键值
var_Empty.removeValueForKey("d")
print(var_Empty)

// MARK:-----------------swift中的空格---------------------
/*
 swift中，不像C、C++、JAVA里面完全忽视空格。swift对空格有一定要求
 */
// 在swift中，运算符不能直接跟在变量或常量的后面
//let let_a= 1 + 2// 报错
//let let_b = 1+ 2// 报错，因为swift认为到1+，这个语句就结束了，从2开始就是下一个语句了
let let_c = 1 + 2// 基于编码规范，推荐使用这种写法
let let_d = 1+2

// MARK:-----------------swift中的元组---------------------
/*
 元组：是一个数据类型，是一个可以返回多个值的数据格式
 在swift中声明元组的时候，用"()"
 元组可以通过下标访问元组元素，也可以通过key的值去访问
 类似于C语言的结构体，可以放多种数据类型
*/
// 定义一个元组
// 方法一：直接初始化一个元组
let status = ("你好", ["iOS", "html5", "Unity"])
// 方法二：给定数据类型
let NewStatus:(String, Array) = ("你好", ["iOS", "html5", "Unity"])

// 取出元组中的值的方法
// 方法一：直接赋值给常量，并通过使用标记名
let statu:(classRoom:String, course:Array) = status
var classInfo = statu.classRoom + statu.course[0] + statu.course[1]
print(classInfo)
// 方法二：通过下标获取元素的值
var classInfo1 = statu.0
print(classInfo1)

var classInfo2 = statu.0 + statu.1[0]
print(classInfo2)
// MARK:--------------------swift中的元组---------------------
/*
 swift中的循环结构包括：for、for-in、while、repeat-while
*/
// for循环
for i in 0 ..< 10
{
    print("it`s my life")
}
// for-in循环
for number in 1..<10
{
    // ..<表示1-9，不包括10
    print(number)
}
for number in 1...10
{
    print(number)
}
// while循环
var j = 5
while j > 0
{
    j -= 1
    print(j)
}
// repeat-while循环：先执行一次循环体，在判断条件(循环体至少被执行一次)
repeat
{
    print("repear...while")
}while 1 < 0
// 循环遍历数组
var animalsArray = ["dog", "cat", "pig", "tiger"];
for a in animalsArray
{
    print(a)
}
// 循环遍历字典
var animalsDic = ["dog":"🐶", "pig":"🐷"];
for(key, value) in animalsDic
{
    print("key = \(key), value = \(value)")
}
// MARK:--------------------swift中的分支结构---------------------
/*
 swift中分支结构：if、if-else、switch...case
*/
// if、if-else
let flag1 = true
if flag1 == true
{
    print("flag1 = \(flag1)")
}
else
{
    print("为假")
}
// switch...case(默认自带break)
let temp = 20
// 特点1：switch中想要实现贯穿，使用关键字
switch temp
{
case 0:
    print("0")
    fallthrough
case 10:
    print("10")
default:
    print("other")
}
// 特点2：case后面可以定义一个变量，where后面是被定义变量需要满足的条件
switch temp
{
case var i where temp >= 0 && temp < 10:
    i = 20
    print(i)
default:
    print("other")
}
// 特点3：case后面可以是一个范围
switch temp
{
case 0..<10:
    print("范围在0-9，不包括10")
case 10...100:
    print("范围在10-100，包括100")
default:
    print("other")
}
// 特点4：switch...case可以匹配一个元组
let point = (10, 10)
switch point
{
case (0, 10):
    print("case1")
case (10, 0):
    print("case2")
case (10, 10):
    print("case3")
default:
    print("other")
}
// MARK:--------------------swift中的枚举---------------------
/*
 C语言中，枚举类型的枚举值和一个整形数值相对应
 而swift中的枚举更加灵活，不必给每一个枚举成员提供一个确定的枚举值，如果给枚举成员提供一个值(称为"原始值")，则该值的类型可以是字符串、字符或是一个整形值或浮点数
*/
// 定义一个枚举值，原始类型为String
enum animalEnum:String
{
    case cat = "🐱"
    case dog = "🐶"
    case duck = "鸭子"
}
print(animalEnum.cat.rawValue)// rawValue指原始值
print(animalEnum.dog.hashValue)// hashValue指哈希值

// 使用原始值创建一个变量
var dir = animalEnum(rawValue: "🐶")// 表示取得原始值为"🐶"的那个枚举成员名，而成员的类型为：animalEnum
print(dir)
// MARK:-----------------------------swift中的函数---------------------------
/*
 swift中里面用"func"表示声明一个函数
 swift的文件格式里面，没有类似于OC的.h文件，所以需要定义一个私有函数，可以在func前面加private
 函数格式：
    func 函数名(参数名:参数类型, 参数名:参数类型, ...)->返回值类型
    {
        实现内容
        return 返回值
    }
 
*/
// 无参无返回值
func sayHi()->Void
{
    print("Hi")
}
sayHi()
// 有参无返回值
func sayHello(baby:String)->Void
{
    print(baby)
}
sayHello("hello")
// 无参有返回值
func money()->String
{
    return "No money"
}
let str = money()
print(str)
// 有参有返回值
func number(a:Int, b:Int)->Int
{
    return a + b
}
var add = number(3, b: 6)
print(add)
// 有参数多返回值函数
func all(number:Int, number2:Int)->(Int, Int, Int, Int)
{
    return (number + number2, number - number2, number * number2, number / number2)
}
let result = all(5, number2: 2)
print(result)
// 内参和外参
/*
 swift中，一个参数有两个名字，内部参数名和外部参数名
 内部参数名：在函数内部使用的参数名称
 外部参数名：在函数调用时显示的参数名称
*/
func hero(first one:String, second two:Int)
{
    print(one, two)// 使用内参
}
hero(first: "盖伦", second: 60)// 显示外参
/*
 注意：
 在默认情况下，函数的第一个参数不显示外部参数名，而其余参数显示外部参数名，并且和内部参数名名字一致
 如果不想显示外部参数名，可以使用"_"省略，但是函数的第一个参数不能使用"_"省略外部参数名
*/
func text(one:Int, _ two:Int)// 下划线后面加空格，不然会报错
{
    print(one, two)
}
text(5, 2)
/*
 inout参数
 函数参数如果不给数据类型，默认为let，如果在参数前面加var，就可以修改参数
 但是，如果参数前面加"inout"来修饰，那么就成了输入输出函数，在函数内部修改参数，可以影响到外部变量的值
*/
var name = "豆豆"
func NewName(inout name1:String)
{
    name1 = "小花"// 修改name值
    print("name修改为：", name1)
}
NewName(&name)// 传的是地址
print("修改后的值name = ", name)

// 函数的嵌套
func outer()
{
    print("外部函数")
    func inside()
    {
        print("内部函数")
    }
    inside()// 在外部函数中调用内部函数
}
outer()// 在外部函数的外面调用外部函数