Swift基本语法及与OC比较之二

//MARK:-----------------控制流-----------------
//MARK: 1.for - in 循环 ,不用声明Value类型

//for value in 1...6 {
//print(value)
//
//}

//不需要具体的值，只是为了得到循环次数

//for _ in 1...6 {
//print("123")
//}

//MARK: 2.for循环，和C一样，只是没有 括号

//for var i = 0 ; i < 26 ; i++ {
//print("i = \(i)")
//}

//MARK: 3.while 循环,和C一致

//var whileValue = 0
//while whileValue < 10 {
//    whileValue++
//
//    print("while ++ -- \(whileValue)")
//}

//MARK: 4. do-while 循环

//var number = 0

//repeat {
//print("number -- \(number)")
//number++
//}while false

//repeat {
//    print("number -- \(number)")
//    number++
//}while number < 10

//MARK: 5. if-else 语句，分支语句
//var applePrice = 8.5 // double
//
//if applePrice < 5 {
//
//    print("applePrice -- \(applePrice)")
//}else{
//    print("applePrice -- \(applePrice)")
//}

//MARK: if-else语句 的值绑定 可以保护程序

//var optionValue :Int?
//var optionValue :Int? = 5
//if var tempOptionValue = optionValue {
//    //如果可选类型有值，就走条件成立的语句
//print("value = \(tempOptionValue)")
//}else{
//    //如果没有值，就走条件不成立的语句
//    print("可选类型为nil")
//}

//MARK: 6.witch - case
//（1）Swift中没有自动贯穿，即使把break删掉，也不会贯穿达下个case语句
//（2）有需要贯穿需求的时候，需要加贯穿语句  fallthrough
//（3）如果case中，没有任何语句，就必须加break ，没有语句就不必加break
//（4）如果不写default，case语句必须包含所有情况。否则必须写。
//var switchValue = 11
//switch switchValue {
//case 10:
//    print("10")
////    break
//case 11:
//    print("11")
////    break
//
//    fallthrough
//case 12:
//    print("12")
////    break
//default:
//    print("other")
//
//}

//MARK: switch -case 的值绑定
//当case条件满足时，进入case语句，把值赋给我们设的局部变量（常量）
//var (x,y) = (0,10)
//switch (x,y){
//case (let localX,0):
//    print("localX = \(localX)")
//case (0,let localY):
//    print("localY = \(localY)")
//default:
//    print("other")
//}

//MARK: switch-case的区间匹配

//var money : Float = 10.5
//switch money {
//case 0...10:
//    print("穷屌丝")
//case 10...100 :
//    print("普通人")
//default:
//    print("高富帅")
//}

/* 词语辨析
fallthrough ：贯穿
continue :结束本次循环，进入下次循环
break：跳出循环
*/

//MARK: 7.标签语
//sign:  主要用于循环嵌套：可以给循环加标签，这样可以给指定循环做一些操作.作用：更易于操作循环
//sign:while true {
//
//    for var i = 0 ; i < 10 ; i++ {
////      指定break是那个控制流
//        if i == 5 {
//        break sign
//        }
//    print("i -- \(i)")
//    }
//}

//MARK: ----------------函数---------------------
//MARK: ----函数调用 --

/*
func 函数名(参数列表) ->返回值 {
//实现动作部分
}

*/

//func 函数名()->返回值
//MARK: 1.无参无返回值 , 没有返回值可以不写 ->\

//func printFunc(){
//
//}

//func printFunc()->Void {
//    print("123")
//}

////diaoyong hanshu
//printFunc()

//MARK: 2.有参无返回值
//func printCity(cityName:String){
//print("城市--\(cityName)")
//}
//
////调用函数
//printCity("郑州")

//MARK: 3.无参有返回值
//func returnString()->String{
//return "北京"
//}
//
//let string = returnString()
//
//print(string)
//
//print(returnString())

//MARK: 4.有参有返回值 :可以支持多个返回值

func matchFun(number1:Int,number2:Int)->(Int,Int){

// number1++
return (number1 + number2,number2 * number1)
}

//print(matchFun(2, number2: 3))

/*注意事项：
1.函数的形参是let类型（常量），而不是变量（变量）；用var修饰形参可改变
2.交换两个数

*/

//1.
func changeCity(var loveCityName:String){

loveCityName = "北京"
//    print(loveCityName)
}

changeCity("上海")

//2.交换两个数
//函数中任意改变形参，实参不会变
//MARK: 注意：要改变实参，需要传进入地址（&）,需要inout关键字---
func changeTwoNumber(inout number1 :Int,inout number2 :Int)->(Int,Int){//（1）

//func changeTwoNumber(var number1 :Int,var number2 :Int)->(Int,Int){//（2）

let tempNumber = number1;
number1 = number2;

number2 = tempNumber;

return (number1,number2)
}

var a = 1,b = 2

let (x,y) = changeTwoNumber(&a, number2: &b)//（1）
//let (x,y) = changeTwoNumber(a, number2: b)//（2）

//print((x,y))
//print("a- \(a),b - \(b)")

//MARK: 给函数添加一个外部形参名，作用：在函数调用时，可以看到

//func travelCity( cityName1:String,CityName:String, cityName3:String){//(1)

func travelCity(firstCity cityName1:String,sencondCity CityName:String,thirdCity cityName3:String){//(2)

//print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
}

//调用

//travelCity("北京", CityName:"马尔代夫", cityName3: "巴黎")//(1)
travelCity(firstCity: "北京", sencondCity: "马尔代夫", thirdCity: "巴黎")//(2)

// 简化的外部参数名：( 只需要在第一个参数名前加外部参数)
func travelCity1(cityName1 cityName1:String, CityName:String, cityName3:String){//(2)

//    print("我的旅行路线\(cityName1)-->\(CityName)-->\(cityName3)")
}

//调用
//travelCity1(cityName1: <#T##String#>, CityName: <#T##String#>, cityName3: <#T##String#>)

//MARK:-----------------函数类型-----------------
//MARK:1.函数类型是由，函数的参数和返回值组成

func addFunc(number1 number1:Int,number2:Int) -> Int{
return number1 + number2
}//这个函数的类型就是  （Int,Int） ->Int

//MARK:2.定义函数类型的变量：类似typeDef
//var tongVar :String = "string"

var tongVar :(Int,Int)->Int = addFunc

//print(tongVar(3,4))

//MARK:3.将函数作为参数
//把addFunc2作为另一个函数的参数
func addFunc2(number1 number1:Int,number2:Int) -> Int{
return number1 + number2
}

//参数1- 参数名：match 参数类型：(Int,Int)->Int
//参数2- 参数名：number1 参数类型：Int
//参数3- 参数名：number2 参数类型：Int

//func ParaFunc(match match:(Int,Int)->Int,number1:Int,number2:Int){
// let resultNumber1 =  match(number1,number2);
//    print(resultNumber1)
//}//(1)

func ParaFunc(addFunc2 addFunc2:(Int,Int)->Int,number1:Int,number2:Int){

//    print(addFunc2(number1,number2))
}//(2)

//调用

//ParaFunc(match: addFunc2, number1: 2, number2: 4)//(1)

ParaFunc(addFunc2: addFunc2, number1: 2, number2: 4)//(2)

//MARK:4函数作为返回值，返回值是一个函数类型

func mutiFun2(number1 number1:Int,number2:Int)->Int{
return number1 * number2
}

//定义一个函数，返回值类型是（Int，Int）->Int
//参数名：add  类型：Bool 返回值类型：(Int,Int)->Int
func selectFunc(isSelectAddFun add:Bool)-> ((Int,Int)->Int){

return add ? addFunc2 :mutiFun2;
}

let result = selectFunc(isSelectAddFun: false)//result 就是函数类型，即(Int,Int)->Int

//print(result(1,2))
//
//print(selectFunc(isSelectAddFun: true)(1,2))

//MARK：函数的嵌套
//func emedFun(judge judge:Bool,number:Int){
//    //自增函数
//    func addNumber(var number1:Int){
//        print(++number1)
//    }
//    //自减函数
//    func jianNumber(var number2:Int){
//        print(--number2)
//    }
//    //    利用bool值去判断，调用自增还是自减
//    let funcName = judge ? addNumber :jianNumber
//    //    利用参数number去调用自增或者自减
//    funcName(number)
//}

//调用

//emedFun(judge: false, number: 1)//在函数外层调用，对应只能调用函数外层

//MARK: 重点------闭包------
//类似OC中的block
//定义一个闭包
var block = { (str:String)-> Void in
//    block块
//    print(str)

}

//调用闭包
block("我爱北京天安门")

//MARK:-----------------枚举-----------------
/*
//1.枚举名首字母大写，枚举值首字母也大写
//2.swift的枚举和C的区别
2.1有case关键字
2.2枚举值有哈希值
*/

/*
enum City{
case beijing
case Paris
case NewYork
}
print(City.NewYork.hashValue)

//3.原始值和rawValue

enum PoneType :String{
case Apple = "IPhone"
case MI = "Mi4"
//    case HUAWEI = "荣耀"
case HUAWEI
}

print(PoneType.HUAWEI.rawValue)//如果有rawValue就会打印，否则打印case后枚举值

//通过rawValue找到对应的枚举值
var ii = PoneType(rawValue: "荣耀")

/*
//print(ii!.rawValue)//强制解析
print(ii?.rawValue)//可选解析
print(ii)//默认为可选解析
*/

*/

//MARK:相关值
//利用枚举的相关值结合switch-case进行值的绑定

enum Girl{
case Id(Int)
case Info(String,Int,Double)//姓名，年龄，身高
}

//进行值的绑定
/*
var girl = Girl.Info("貂蝉", 21, 165)

switch girl {
case Girl.Info(var girlName,var age,var height) :
print("name --\(girlName)")
case Girl.Id(var girlID):
print("ID -- \(girlID)")
}
*/
//MARK:-----------------类-----------------

/*和OC区别：

1.运用class关键字
2.没有.h .m
3.在同一个括号内声明属性，书写方法

*/

//定义一个类,关键字是Class，类名首字母大写
class Student {
//类的属性（实例变量）,属性名studentAge，类型Int
var studentAge :Int
var studentName:String
//    给属性添加init方法，目的为给属性一个默认值
init(studentAge:Int,studentName:String){//一个类只能有一个init方法
//    给属性赋默认值
self.studentAge = studentAge
self.studentName = studentName
}

//MARK:注意--类方法 （函数）
func printStu(){
print(self.studentAge,self.studentName)
}

//    有参数有返回值
func  change(stuName:String)->String{
self.studentName = stuName
return self.studentName
}
}

//调用该类
//实例化一个类对象
let studentItem = Student(studentAge: 26, studentName:"我饿了")
//属性的设置和访问

studentItem.studentAge = 24;

//print(studentItem.studentAge)

//studentItem.printStu()

//print(studentItem.change("嗯哼"))

//MARK:   ---结构体---
//定义一个结构体，关键字struct
//结构体不需要写init方法，因为它已经为我们写好了
struct GirlSTR {
//属性
var girlName:String
var girlHeight:Double

//    方法
func printFourBeautifulGirls(girlName1:String ,girlName2:String, girlNmae3:String){//注意‘,’不可少
print("四大美女---\(self.girlName) \(girlName1)  \(girlName2)  \(girlNmae3)")

}

func printHeith(){

print(self.girlHeight)
}
}

//实例化一个结构体

var girl = GirlSTR(girlName: "小笼包", girlHeight: 20)

//访问结构体的属性，设置结构体属性
//print(girl.girlName)
girl.girlHeight = 1.60
//girl.printHeith()
//girl.printFourBeautifulGirls("1", girlName2: "2", girlNmae3: "3")

//MARK:类和结构体的区别

//1.类是引用类型，结构体是值类型
var studentItem2 = studentItem;
studentItem.studentAge = 2

print(studentItem.studentAge,studentItem2.studentAge)

var girl2 = girl
girl.girlHeight = 1.20
print(girl.girlHeight,girl2.girlHeight)

//2.类可以继承，结构体不能继承（最本质）

//3.结构体对象如果是let类型即使属性是var类型也是不可修改的。类对象即使是let类型，属性如果是var类型也是可以修改的

//MARK:恒等运算 ===
//用来对两个类实例（对象）进行判断，到底是否完全一致

if studentItem2 === studentItem {
print("两个实例相等")

}else{
print("两个实例不相等")
}