声明变量和常量

//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
    }
}

补充：结构体和枚举中也可以定义方法