print("这是学习 swift 的第一课")

  var varA = 

  print("a 的值是 \(varA)")

  //注：字符串打印参数时，参数是这样的 \(参数)

 var  a =  // (Int 类型)

 var  b = 1.0//（Double 类型）

 let   c = "创建个字符串，怎么样" //（String 类型）

 //注：var 定义的是变量 ：值是可以修改的

 a =  //（不会报错）

 c = "修改下字符串"  //（报错 这个值 是不可以修改的）

 var intA ：Int = 

 let  string ：String = "常量的字符串"

  let score =  //及格分数

  let scoreArr = [,,,,,,] // 分数的数组

  let count = scoreArr.count

 func  judge(sco:Int){

         if  sco < score {

            print("不合格分数是 \(sco)")

          }

     }

   //或者使用简单的switch 语句 可以更细致分析分数

    func judge(sco:Int){

            let pass = (sco > score)

            switch pass {

            case true:

                print("及格的分数是 \(sco)")

//                fallthrough; // 贯穿效果的语句 ，这里暂时不使用

            default:

                print("不及格的分数是 \(sco)")

            }

        }

 //for 循环的遍历：

  for s in scoreArr {

            print("分数是 \(s)")

            judge(sco: s)

        }

   for i in ...count-{

            print("分数是 \(scoreArr[i])")

            judge(sco: scoreArr[i])

        }

    for j in ..<count{

            print("分数是 \(scoreArr[j])")

            judge(sco: scoreArr[j])

         }

  //while 循环的遍历：

        var index =

        while index < count {

            judge(sco: scoreArr[index])

             index +=

        }

   func testConnect(v1:String, v2:String) -> String {//有参数 又返回值

        return v1 + " " + v2;

    }

 //  调用：

    var connectString = self.testConnect(v1: "hello", v2: "world")

        print("connect string is \(connectString)")

    func testLog(){//无参数 无返回值

        print ("log 成功")

    }

   // 调用：

    self.testLog()

    func logString(logString:String)  {//有参数 无返回

        print (logString)

    }

//    调用：

self.logString(logString: "logSuccess")

    func testBool() -> Bool {//无参数 有返回

        return true

    }

    func testParement() -> (String,String,String) {//多个返回值

        return ("parement1","parement2","parement3")

    }

//     调用：

 let (parement1,parement2,parement3) = self.testParement()

    func addParement(parement : Int) -> Int {//函数中包含函数

        var v1 = parement

        func add(){//是一个函数

            v1 +=

        }

        add()

        return v1

    }

//    调用：

 let result = self.addParement(parement: )

    func funcPointer( isBool : Bool ) ->( (Int) -> Int)  { //返回 函数指针

       func addOne( num:Int ) -> Int{

            return num+;

        }

        func subtractOne( num:Int ) ->Int {

            return num-;

        }

        if isBool {

          return  addOne

        }

        return subtractOne

    }

//    调用：

let  resultPinter = self.funcPointer(isBool: false)

        let resu = resultPinter()

    func hasAnyMatch(arr : Array<Int> ,condition:(Int) -> Bool) -> Bool {

        for s in arr {

            if condition(s) {

                return true

            }

        }

            return false

    }

    func  lessThanSixty(s :Int) -> Bool {

        if s <  {

            return true

        }else{

        return false

        }

    }

//  调用：

if self.hasAnyMatch(arr: scoreArr, condition: lessThanSixty) {//把lessThanSixty 

//这个函数名字 当做参数 传入方法

         print("含有不及格的")

        }else{

            print("都是及格的")

        }

 var p1 = ;

    // 字符串：

        let p2 = "value is " + String(p1) //这里包换一个强转的方法

        print("p1 is: \(p1),p2 is: \(p2)")

   //  数组  : 

       var p3 = ["ios","andriod","symbian"]

        print("p3 is: \(p3)")

        p3[] = "ios/swift" //修改数组元素

        print("p3 is: \(p3)")

        p3.append("ios/oc")// 末尾添加元素

        p3.insert("windows phone", at: )// 指定位置添加元素

        print("p3 is \(p3)"

        p3.removeFirst()//删除元素

        p3.removeAll()//删除元素

        print("p3 is \(p3)")

     //字典：

        var p4 :Dictionary = [

            "name":"Bob",

            "age":,

            "professional":"计算机开发"

            ] as [String : Any]

        for (key,value) in p4 {

            print("key is:\(key),value is:\(value)")

        }

        p4["score"] = ;//添加

        let p5 = p4.keys

        for key in p5{

            print("\(key) = \(p4[key])")

        }

      //元祖：

  let http404Error = (, "Not Found")

  print("The status code is \(http404Error.0)")

 // 方法 ：

       func hasConnditionMatch(arr:Array<Any>,value:Int,

                            conndition:(Int,Int)->Bool) -> Bool {

        for item in arr{

            if  conndition(item as! Int,value){

                return true;

            }

        }

        return false;

    }

//    调用：

       var arr = [,,,,,,,,,]

        var v2 = hasConnditionMatch(arr: arr,value: ,conndition: {

            (num:Int,value:Int)->Bool in

            return num>value;

        });

        print("v2 value is:\(v2)")

        var v3 = hasConnditionMatch(arr: arr,value: ,conndition: {

                                  return $ > $;

        });

        print("v3 value is:\(v3)")

    //注：闭包 让各个函数之间的通信比较方便

enum Direction{
        case North,South,East,West
       }
      enum Direction1{
            case North
            case South
            case East
            case West
        }
    注 ：这两种定义方式是一样的效果
 
        var d1 = Direction.East
        d1 =  .West / /已经知道d1 是枚举的类型 ，所以可以直接使用 点语法
        
        var d2 :Direction = .East
        switch d1 {
        case .East:print("指向东方")
        case .West:print("指向西方")
        case .North:print("指向北方")
        case .South:print("指向南方")
        default:
            print("没有这个方向")
        }

enum phoneType:Int{
            case andriod = 0 ,ios ,windows,macOS
        }
        注： 枚举值是可以 有数值类型的

var  type = phoneType.ios

let t = type.rawValue//找到是第几个枚举，枚举值 转化成 Int 值
        print("raw value is :\(t)")
       
        var type1 = phoneType.init(rawValue: 3)//获取对应的枚举， 把 Int 转化为 枚举
        print("type1 is :\(type1)")

   struct point {

            var x = ;

            var y = ;

        };

        var point1 = point(x:,y:)

        print("point1 \(point1.x) \(point1.y)")