声明变量和常量
//1.基本数据类型：Int 整形，Double 和Float表示浮点型，Bool布尔值，String文本型数据，Array 数组，Dictionary 字典
//2.常量 let ，变量var
let con = 100
var avi = 30
avi = 40
//3.一行中声明多个常量或者变量，用逗号隔开
var a = 3, b = 4, c = 5
//4.类型标注：如果声明的同时附了初始值，并不需要类型标注
var who: String
who = "xiaoming"
print(who)
swift的基本语法
类型转换
//类型转换
let a: UInt8 = 10
let b: UInt16 = 110
print("\(UInt16(a) + b)")
//整形转变成浮点型
let sa = 3
let pi = 3.1415
let add = Double(sa) + pi
print(add)
元组
//元组的补充：可以把任意的类型组合成元组，元组可以看成是一个复合的值
let people = (18, "xiaoming")
//可以把元组的内容单独的分成常量和变量
let (age, name) = people
print(age)
print(name)
//如果我们只是需要一部分元组值，则可以把要忽视的部分用下划线进行标记
let (age1, _) = people
print(age1)
//通过下标也可以访问元组中的元素
print(people.0)
//定义元组的时候也可以根据单个元素命名,通过名字获取元素的值
let rec = (w: 10, h: 20)
print(rec.w)
可选类型
//可选类型：处理值可能缺失的情况，可以表示任意类型的值缺失的情况
let str : String? = "12345"
//用if语句表示是否是可选类型
if str != nil {
print(str!)//只有加上!才能获取可选类型的值，表示对可选类型的强制解析
}
//判断可选类型是否包含值的方式称为可选绑定,在它的语法中可以声明常量接受，也可以声明变量接受
/*
可选绑定可以用if和while语句中来对可选类型的值进行判断，并赋值给常量或者是变量
注意点：在swift中nil表示的是一个确切的值，而在oc中他表示一个指向不存在对象的指针
*/
if let str1 = str {
print(str1)
}
var servercode : Int? = 404
servercode = nil //现在servercode 不包含值
var sunny : String?
//隐式解析可选类型：当确定一个变量的值已定不为nil时，就可以把它设置成隐式解析可选类型
//第一次被赋值之后，可以确定变量的值不为nil
var possiblestr: String! = "swift"
print(possiblestr)//可以不通过!来获取变量的值
断言
//在值缺失，或者值并不满足特定的条件，代码就不会继续执行，此时需要触发一个断言结束代码的运行，通过调试找到值缺失的原因
let age2 = -10
assert(age2>=0, "年龄要大于0")//assert就表示一个断言，只有保证条件为真时，才能保证代码可以继续运行
运算符
//2.溢出运算符:在运算符的前面加上&符号 &＋，&－， &＊
var c = UInt8.min
c = c &- 1
print(c)
//swift可以对浮点数求余，而在oc中是不可以的
var rem = 10 / 2.3
print(rem)
//空合并运算符（a ?? b 对a的条件进行判断，a不为nil执行a的语句，否则执行b的语句）
/*
表达式a必须是可选类型
默认值b的类型必须要和a存储值的类型保持一致
*/
let words = "hello"
var say: String?
var content = say ?? words
print(content)
//闭区间运算符a...b 半开区间运算符a..<b , 注意中间没有空格
for i in 1...5 {
print(i)
}
字符串
//字符串
var str1 = "swift"
var str2 = String()//初始化字符串的实例
var str3 = str1 + "学习"//字符串的拼接可以使用+号
print(str3)
str1 += "你好"//+=将字符串拼接到自身
print(str1)
let char : Character = "!"
str1.append(char)
print(str1)//append拼接字符
print("str3 has \(str3) chars")
let quotation = "same"
let samequ = "same"
if quotation == samequ {//判断字符串是否相同
print("same")
}
var food = ["fruits:apple",
"fruits:orange",
"fruits:banana",
"vegetable:tomato",
"vegetable:potato"]
for fru in food {
if fru.hasPrefix("fruits"){//hasPrefix查找特定的前缀
print(fru)
}
if fru.hasSuffix("apple"){//hasSuffix判断是否拥有特定的后缀
print(fru)
}
}
数组
//数组的声明可以是显性声明，也可以推断出数组的类型。数据放在数组之前，它的类型必须明确。
food.append("vegetable:aaaa")//通过append添加新的数据项
food[0...2] = ["ss", "nn"]//可以通过下标值替换数组中的元素。若替换的下标有3个，而右边只有2个值，则swift会自动赋值为nil
print(food)
food.insert("meat", at: 0)//通过insert插入元素
food.remove(at: 0)//通过remove方法可以移除数组中的元素
food.removeLast()//移除最后一项的元素
//使用构造语法来创建一个由特定类型构成的空数组
var someint = [Int]()
print("someints is of type [int] with\(someint.count)items")
//可以创建特定大小并且所有数据都被默认的构造方法 如：浮点型，3个
var threedouble = [Double](repeating: 0.0, count: 3)
字典
//字典
/*
swift的字典使用时需要具体规定可以存储的键和值的类型，必须提前定义清楚，方法是通过显性类型标注或者是类型推断
*/
var person = ["age": 18,
"name": "jack"] as [String : Any]
/*updateValue方法会在键不存在的时候设置值或者在键存在的情况下更新值。这个方法会返回更新值的原值，
这样方便我们检查更新是否成功
*/
if let oldname = person.updateValue("tom", forKey: "name") {
print("原来的值：\(oldname)")
}
/*
2.removeValue方法也可以用来在字典中移除键值对
3.每一个字典中的数据项都有（key, value）元组的形式返回，并且我们可以使用临时常量或者变量分解这些元组
*/
for (key, value) in person{
print(key,value)//字典元素是无序的，遍历的时候不能保证顺序
}
var dic = Dictionary<Int , String>()//声明空字典
dic[16] = "年龄"//为键为16，赋值为年龄
print(dic)
dic = [:]//声明空字典的方式二
控制流
//控制流
let base = 3
let power = 10
var answer = 1
for _ in 1...power {//下划线符号_(替代循环中的变量)能够忽略具体的值，并且提供循环遍历时对值的访问
answer *= base
}
print(answer)
//在switch中case中可以省略break
let count = 3_000_000_000
let countedthings = "stars in the milky way"
var naturalcount : String
switch count {
case 0:
naturalcount = "no"
case 1...3:
naturalcount = "a few"
case 4...9:
naturalcount = "several"
case 10...99:
naturalcount = "tens of"
case 100...999:
naturalcount = "hundreds of"
case 1000...9999:
naturalcount = "thounds of"
default:
naturalcount = "millions and millions of"
}
函数
//函数
//函数的声明格式：带一个参数，有返回值的函数
func sayhello(personname: String) -> String{
return "hello" + personname + "!"
}
//调用函数
print(sayhello(personname: "anna"))
//带有2个参数有返回值的函数，中间用逗号分开
func lengthnumber(start: Int, end: Int) -> Int{
return end - start
}
print(lengthnumber(start: 1, end: 10))
/*
局部参数名 例如personname，只能在函数体内使用，外部参数名写在局部参数名之前，用
空格进行分割。
*/
func join(s1: String, toString s2: String, withjoiner joiner: String) -> String {
return s1 + s2 + joiner
}
print(join(s1: "hello", toString: "swift", withjoiner: "!"))
/*
joiner的值没有被指定，函数会使用默认值（""），当未给带默认值的参数提供外部
参数名时，swift会自动提供外部名字。此时，外部参数名字和局部参数名字是一样的
*/
/*
没有指定返回类型的函数返回void。 在swift中，void和空的元祖是一样的
*/
func addtwoints(a: Int, b: Int) -> Int{
return a + b
}
func multiplytwoints(a: Int, b: Int) -> Int{
return a*b
}
/*
定义一个叫做mathfunction的变量，类型是‘一个有2个int 类型的参数，并返回一个int类型值的函数’
*/
var mathfunction: (Int,Int) -> Int = addtwoints
print("results:\(mathfunction(2, 3))")
/*
函数也可以当作参数
*/
func printmathresult(mathfunction: (Int, Int) -> Int, a: Int, b: Int){
print(mathfunction(a, b))
}
print(printmathresult(mathfunction: addtwoints, a: 3, b: 5))
类
//类
//用class关键字进行标记
class person {
//定义参数
var name = "tina"
var age = 19
//定义函数
func produce(){
age += 1
}
}
补充：结构体和枚举中也可以定义方法
