Swift基础语法1

import UIKit

/*

//定义一个常量
let gender : Bool = true;

//定义一个变量

var age : Int = 27;

print(age)
print(gender)

let view : UIView = UIView()
print(view)

//类型推到

let b = 3.14
let c = 10

//swift中没有隐式转换 所以 swift的计算 必须保持类型一致 不然就会报错

let x = 3
let y = 10.1

let z = Double(x) + y



//逻辑分支 if/switch 三目运算符

 if后面的小括号可以省略
 if后面的表达式 不在有【非零(nil)即真】表达式 必须有明确的真假(Bool)




let abc = 10

if abc > 0{

    print("abc > 0");

}
else{

    print("abc <= 0")

}

//三目运算符

let abc2 = true

//OC int a = abc2? 100:200 -->100



var result = 0

let m = 20
let n = 30

if m > n {
    result = m
}
else{
    result = n
}

print("%d", result)

//三目运算符和原来OC的语法完全一致
let result2 = m > n ? m:n



//逻辑分支 guard的使用 翻译成 守卫
//guard可以完全用if来代替 但是可读性比if好  
//语法要求 guard 必须 和 else 配对使用

 guard语法如下：
 1.当条件表达式为ture时 跳过else语句中的内容，执行语句组内容
 2.当条件表达式为false时 执行else语句中的内容，跳转语句一般是 return break continue throw
 3.guard 必须在函数中才能使用

 实例

 guard 表达式 else{
    return
 }
 语句组

 其实这里用if也可以做到

 if(abc){
    return
 }
 ...





let myAge = 27

func isAbleOnline(age:Int){
    if age >= 18 {
        print("可以上网")
    }
    else{
        print("不可以上网")
    }
}

isAbleOnline(age:myAge)


func isAbleOnline2(age:Int){
    guard age >= 18 else {
        print("小伙子 你未成年啊")
        return
    }

    print("你可以上网")

}

isAbleOnline2(age:16)



 switch的用法
 基础用法
 1.switch后的（）可以省略
 2.case语句结束后的break也可以省略
 3.如果想在case中产生穿透 可以在case结束后面跟上 fallthrough
 4.case后面可以跟多个条件 用逗号,分割

 let gender = 0//0:男 1:女 3:其他

 switch gender {
 case 0:
 print("男")
 fallthrough
 case 1:
 print("女")
 default:
 print("其他")
 }

 switch gender {
 case 0, 1:
 print("正常人")
 default:
 print("其他")
 }


 特殊用法
 1.switch 可以判断 浮点型
 2.switch 可以判断 字符串
 3.switch 可以判断 区间 [区间：数学里面的 开区间 闭区间]

 swift语法中
 开区间    0..<10  表示 数学表达式:[0,10) 不包括10
 闭区间    0...10 表示 数学表达式:[0,10] 包括10 个人感觉数学的表达看起来更好理解 swift为毛不这么设计。。。


 判断浮点数
 let pi = 3.14

 switch pi {
 case 3.14:
 print("pi 是 π")
 default:
 print("pi 不是 π")
 }


 判断字符串
 let name = "kenshin"

 switch name {
 case "kenshin":
 print("your name is kenshin")
 default:
 print("your name not kenshin")
 }

 判断区间

 错误写法
 let score = 98

 switch score {
 case 0..<60:
 print("成绩：不及格")
 case:60..<80
 print("成绩：良好")
 case:80..<90
 print("成绩 优秀")
 case:90..<101
 print("成绩 扎心了 老铁 成绩很好！")
 default:
 print("成绩 无效")
 }

 注意: 上面的case的冒号 应该写在表达式的后面

 let score = 98

 switch score {
 case 0..<60:
 print("成绩：不及格")
 case 60..<80:
 print("成绩：良好")
 case 80..<90:
 print("成绩 优秀")
 case 90...100:
 print("成绩 扎心了 老铁 成绩很好！")
 default:
 print("成绩 无效")
 }

 循环的使用

 for while  do while

 //for的写法 3.1开始 不支持写 i++/i--了
 for index in 1...5 {
 print(index)
 }

 //for in 的写法
 for i in 0..<10{
 print(i)
 }

 for i in 0...9{
 print("Hello World")
 }

 //在swift中 如果以个标识符不需要使用 可以用_来代替

 for _ in 0...9{
 print("kenshin")
 }


 var num = 10

 while num > 0 {
 num -= 1
 print("kenshin")
 }

 do while 变成了 repeat while

 var a = 0
 repeat{

 a += 1
 print(a)

 }while a < 10

 字符串
 //1.字符串的定义
 //let str : String = "kenshin"
 let str  = "kenshin"
 let str2 = "希望"

 //2.遍历字符串
 for tmpStr in str.characters{
 print(tmpStr)
 }

 //3.字符串的拼接
 let str3 = str + str2
 //3.2 字符串和其他标识符之间的拼接
 let age = 18
 let name = "kenshin"
 let height = 172

 let info = "my name is \(name) age is \(age) height is\(height)"

 //3.3字符串格式化 高位不足 补零
 //例如 时间字符串
 var min = 18
 var second = 8
 var time = String (format: "%02d:%02d", arguments:[min, second])

 //字符串的截取
 let net = "https://github.com"
 let head = (net as NSString).substring(to: 5)
 let middke = (net as NSString).substring(with: NSMakeRange(8, 6))
 let end = (net as NSString).substring(from: 15)

 //数组

 //let 定义不可变数组
 let arr1 = ["小新", "广志", "美伢", "小白", "小葵", "风间", "阿呆", "正南"]


 //var 定义可变数组 下面的两种写法是一个意思 推荐使用第二种 一个意思？ 那swift是不是傻逼了？
 var mArr1 = Array<String>()
 var mArr = [String]()

 //可变数组的常用操作

 //1.添加元素
 mArr.append("kenshin")
 mArr.append("tomoe")
 mArr.append("kakome")

 //2.删除元素
 mArr.remove(at: 0)//返回发出的元素

 //3.修改元素
 mArr[0] = "imiyashiya"
 mArr

 //4 遍历数组
 for str in arr1{
 print(str)
 }

 for str in mArr
 {
 print(str)
 }

 //数组的合并 数组中的元素是相同的类型 才能相加合并
 let arr3 = arr1 + mArr

 let array  = [18, 27, 172]
 let array2 = ["kenshin", "xun"]

 //字典 swift中的字典和数组一样 也是一个泛型集合 泛型的意思就是 限定类型

 //1.定义字典
 //1.1定义不可变字典 let 系统会自动判断后面定义的是字典还是数组
 let dic1 = ["name":"kenshin","wife":"kodoko"]

 //1.2定义可变字典 var
 var mDic1 = [String:String]()

 //2.对可变字典的基本操作
 //2.1添加元素
 mDic1["name"] = "kenshin"
 mDic1["like"] = "basketball"
 mDic1["dream"] = "happiness"

 //2.2删除元素
 mDic1.removeValue(forKey: "like")
 mDic1

 //2.3修改元素
 mDic1["dream"] = "happy"
 mDic1

 //2.4获取元素
 mDic1["name"]

 //3.遍历字典中所有的key
 for key in mDic1.keys{
 print(key)
 }
 //3.1遍历字典中所有的value
 for str in mDic1.values{
 print(str)
 }
 //3.2遍历字典中所有的键值对
 for kv in mDic1{
 print(kv)
 }

 for (key, value) in mDic1{
 print(key, value)
 }

 //4.合并字典 即使类型一致 也不能相加进行合并 可以通过遍历合并
 var dic4 = ["name":"kenshin", "dream":"inLove"]
 var dic5 = ["lover":"kodoko", "son":"sky"]

 for (key, value) in dic4{
 dic5[key] = value
 }
 dic5

 //元组是OC中没有的概念[元祖一般用于作为方法的返回值]
 元组是一种数据结构，在数学中应用广泛
 类似于数组或字典
 可以用于定义一组数据
 组成元组类型的数据可以成为“元素”

 //1.使用数组定义一组数据
 let arr = ["fxw", 27, 172.5] as [Any]
 arr[0]
 arr[1]
 arr[2]


 //2.使用字典定义一组数据
 let dic = ["name":"fxw", "age":27, "height":172.5] as [String :Any]
 dic["name"]
 dic["age"]
 dic["height"]

 //3.使用元组定义一组数据
 //3.1元组最基本的写法
 let info = ("fxw", 1.88, 27)
 info.0
 info.1

 //3.2可以给元组中的每一个元素取一个别名[常用]
 let info2 = (name : "fxw", height : 1.88, age : 27)
 info2.name
 info2.age

 //3.3用元祖的别名来定义元祖，别名对应其元素
 let (name, age, height) = ("kenshin", 27, 1.88)
 name
 age
 height


 可选类型 [OC里面没有] 这个概念暂时不好理解

 由来：OC中 变量默认初始化值为 0 或者 nil 等，但是在swift中nil也是一个类型，它不能喝其他类型直接赋值[因为swift是强类型语言]
           但是开发过程中很多时候需要给一些参数赋默认值，因此出现了 可选类型

 //var  str : String = nil 错误写法

 //swift中有规定：对象中的任何属性在创建对象时，都必须有明确的初始化值 所以下面的代码会报错
 //class Person:NSObject{
 //    var name:String
 //
 //}

 //1.定义可选类型
 //1.1常规定义(不常用)
 var name : Optional<String> = nil

 //1.2语法糖(常用)  1.2的写法 和 1.1的写法意思是完全一样的 只是变得更加简洁
 var name2 : String? = nil

 //2 给可选类型赋值
 name2 = "kenshin"

 //3 取出可选类型中的值 在可选类型后面加上感叹号 如: name! 这样做的目的是 强制解包
 print(name2)//"Optional("kenshin")\n"
 //print(name2!)//"kenshin\n"


 //4.注意 强制解包是非常危险的操作，如果可选类型的值为nil 强制解包 系统会崩溃
 //      建议 在强制解包前 先对可选类型的值 进行判断 如果为nil 就不要进行强制解包
 if name2 != nil{
 print(name2!)
 }

 //5.可选绑定 其实就是一个if条件判断

 //写法一：不常用
 //下面代码做了两件事情
 //1.判断name2是否有值， 如果没有就不执行{中的内容}
 //2.如果name2有值，系统会将其强制解包并赋值给tmpName
 if let tmpName = name2{
 print(tmpName)
 }

 //写法二：常用
 if let name2 = name2{
 print(name2)
 }

 //可选类型使用场景
 //当字符串中包含中文时 返回的url是nil 这个时候强制解包就会崩溃 通过 可选绑定的方式使得程序变得更加安全
 let url : NSURL? = NSURL(string:"https://github.com/wokenshin呵呵")

 //可选绑定
 if let url = url{
 print(url)
 }

 函数的基本使用
 函数 在OC中 对应 OC的方法

 格式

 func 函数名(参数列表) -> 返回值类型{
    代码块
    return 返回值;
 }

 func是关键字，多个参数列表之间可以用逗号(,)分割，也可以没有参数
 使用箭头"->"只想返回值类型
 如果函数没有返回值，返回值为Void. 注意这里的V大写，也可以直接 省略 箭头"-> 和返回值类型“

 //1、没有参数没有返回值的函数
 func info() -> Void {
 print("我的名字叫 kenshin 今年27岁 我是一名iOS程序员")
 }

 info()

 func info2() {
 print("我的名字叫 kenshin 今年27岁 我是一名iOS程序员")
 }

 info2()

 //2、没有参数有返回值的函数
 func read() -> String{
 return "kenshin"
 }

 var message = read()


 //3、有参数没有返回值的函数
 func read(name:String){

 print("your name is \(name)")

 }

 read(name:"kenshin")


 //4、有参数有返回值的函数
 func sum(num1:Int, num2:Int) -> Int{

 return num1 + num2

 }

 sum(num1: 1, num2: 2)

 函数的使用注意：
 1.为参数设置默认值，在调用函数时，如果不传改参数，择函数内部认为该参数为一个默认值,实现方式: 在参数列表后面 加上等号 并赋值默认值即可
 //请不要在意这些细节...
 func makeGirl (jpGirl : String = "波多野结衣") -> String{
 return "your need girl is \(jpGirl)"
 }

 makeGirl(jpGirl: "雨宫琴音")
 makeGirl(jpGirl: "橘梨纱")
 makeGirl()

 2.可变参数 参数列表中 参数后面跟上 ...
 func sum (num : Int...) -> Int
 {
 var result = 0
 for i in num{
 result += i
 }

 return result

 }

 sum(num: 1,2,3,4)

 3.指针类型
 var m = 1
 var n = -1

 func fxw_swap( m:inout Int, n:inout Int){
 let t = m
 m = n
 n = t
 }

 fxw_swap(m: &m, n: &n)
 print("m:\(m) n:\(n)")

*/