Swift

// 变量声明规则
// var（let）变量名 = 值
// 类型推断---根据给出的值对变量的类型进行判断

// *************************基本数据类型
var a = 10
var b = 20

// 关于类型推断，在32位系统整形自动推断为Int32
                 // 64位系统 Int64

let maxNumberOfStudent = 40

a++
++b

// 指定变量类型 语法(变量：类型)
// 如果给变量指定类型，可以暂时先不给初值，但是在第一次使用之前需要给值
var currentStudent:Int
currentStudent = 50
currentStudent++

// 浮点数自动类型推断为 Double---双精度
var score = 90.2
// 如果需要float类型，需要类型指定
var score1:Float = 90.3
// 由于Swift安全性，在swift中不支持隐式类型转换
// 必须转成相同类型进行加法操作
// 类型转换
var score3 = Float(score) + score1
var score4 = score + Double(score1)

// ****************字符串
// 字符串自动推断为 String类型
let name = "阳阳阳"
// 字符型
let char:Character = "a"
let name2:String = "nnn"
let loClass = "BJS150516"

// +运算符--- 重载运算符 源于C++ --- 用于运算符的拼接

let myyangyang = loClass + name


/// String与NSString类型不同


var strTest = "my name is XXX"
// String.Index 类型
// 获取字符串末尾位置
var indexCC = strTest.endIndex
// 获取前一个位置
indexCC.predecessor().predecessor().predecessor().predecessor()
//获取后一个位置
//indexCC.successor()


var strResult = strTest.substringToIndex(indexCC.predecessor())

// 转换为NSString类型
// as 强制声明
var ns1 = (strTest as NSString).substringToIndex(6)
var ns2 = (strTest as NSString).substringFromIndex(2)
var ns3 = (strTest as NSString).substringWithRange(NSMakeRange(4, 2))


print(ns3); print(ns3); print(ns3)

// 自带换行符
println(ns3); println(ns3)

var Test2 = "helllo world"
let index = advance(Test2.startIndex, 3)
let index2 = advance(Test2.endIndex, -3)

//var range = Range<String.index>(start:index,end:index2)

strResult = Test2.substringToIndex(index)

// 在swift中，变量/常亮名几乎支持所有的unicode编码的字符，除了数学中的符号，下划线，箭头
var 😊 = "阳阳阳"
😊

var 阳阳阳 = "yangyangyang"
阳阳阳


/**
*  数组 --- 在swift中，数组是Array类型，使用规则是，数组一般存放相同类型的数据
*/
var array = [1,2,3]
var array1 = [1,2,"3"]
var array2 = ["1","2","3"]

// 声明数组类型 语法： [参考类型]
var array4: [Int] = [1]


// 声明数组类型 语法： Array<参数类型>
var array5: Array<String>  = ["a"]

// 增加
array.append(4)
array.insert(6, atIndex: 2)
array.last
array.first

// 删除
//remove的返回值是被移除的元素
array.removeAtIndex(0)
array

// 更改


// 查询

array[0] = 8
array

var array6 = [22,33]

// +重载
array += array6

// 区域运算符符
// ...  1...2从1到2闭区间
// .. < 1...<2从1到2开区间

array[0...1]
array[0..<1]

array[0..<1] = [9,9,9] // 区间替换
array

array[3...5] = [1,2,3]
array
*/




/**
*  字典 --- 键值对数组
   字典使用潜规则 --- 键值类型相同     值类型相同    键和值的类型可以不同
*/

/*

var dictionary = ["key1":1,"key2":2]
// 声明字典类型语法1 [键值类型 ： 值类型]
var dictionary2:[String: Int] = ["key3": 3]

// 语法2 Dictionary<键类型，值类型>
var dictionary3: Dictionary<String,Int> = ["key4":4]


// 查询

dictionary3["key4"]


// 如果可以存在则执行更新操作，key不存在则执行添加操作
// 字典中元素没有顺序
dictionary["key1"] = 11


// 删除
var indexDDD = dictionary.indexForKey("key2")
dictionary.removeAtIndex(indexDDD!)


// ******************可选类型 optional
// 只要想用nil,就必须将变量声明成可选类型
// var error = nil

// ?打包：因为已知此存储空间值可能为空，从swift安全性角度考虑，需要声明可选变量的开发人员负责此空间的安全
// 解包：当变量解包时，是否为空的情况要开发人员自主把控

var error :String? = nil
error = "Not Found!" // 赋值不需要使用！（解包）
error! += "!!!" // 使用可选变量的时候需要使用！（解包）
error

// **************元组
// 语法  源于关系型数据库的概念，在关系型数据库中，一条数据可以相当于是一个元组，里面包含不同类型的数据
// 元组可以作为函数返回值返回，处理多返回值类型

var status = (404,"Not Found!!!")
status.0
status.1


var status2:(num:Int,info:String) = status
status2.num
status2.info


*/


/**
*  分支语句
*/

/*

// if的条件 必须是bool值或者 bool表达式 --- 不能直接使用对象

var isOrNo = true // bool值必须使用true或者false
if isOrNo {

    println("true")

}else{

    println("true")
    
}


var count: Int? = nil
count = 20

if count > 10 {

    // 在输出函数中，使用\()进行变量的输出拼接
    println("count = \(count)")
}else{

    
}


if count == nil {

    println("count == nil")
}else{

    println("count = \(count)")
}


// 使用创建语句作为条件，编译时else分支会默认变量创建失败，不予使用
if let count2 = count{
    println("count2 = \(count2)")
}else{

    
}


// 为了swift的安全性，分支语句条件必须完整

// 循环
var number = 0
while number < 10{

    println("number = \(number)")
    number++
}


var number1 = 0


/// for循环
//var number2 = 10
for var number2 = 10; number2 > 0; number2-- {

    println("number2 = \(number2)")
    
}


/// do while 语句
var number3 = 10
do {

    number3--

}while number3>0



var array = ["1","2","3"]
for value in array {

    println("value = \(value)")
}


// 条件可以省略，分号不可以
var num = 0
for ; num < 10;{
    println(num)
    num++
}

// 使用元组 枚举数组时  元组的第一个元素代表的是数组中元素的小标，第二个元素代表的是数组的元素
var array7 = ["a"]
for (index,value) in enumerate(array7) {
    println(index)
    println(value)
}



var dict = ["key":"123"]
// 如果使用一个元for in 字典的话，将枚举出键值对
// 并且键值对以元组的形式体现，可以根据下标获取
for value in dict{
    
    println(value)
    value.0
    value.1
}

// 使用元组枚举字典的时候，不需要使用enumerate关键字
for (key,value) in dict {

    println(key)
    println(value)
}

// 占位符_,如果想忽略掉 元组中的值，使用占位符进行忽略 --- 忽略
for (_, value) in dict{

    println(value)
}


for (key, _) in dict{
    
    println(key)
}

// 区域占位符
for value in 1...10{

    println(value)

}

for value in array[0...1] {

    println(value)
}
*/

// ****************************switch


// 1.switch语句中，每个分支自带有break
// 2.switch语句，只要case将所有情况列举，default可以省略，必须包含所有可能情况
// 3.fallthrough使执行下一个分支，只在当前分支内有效
var point = (2,0)

switch point {
case (0,0):
    println("原点")
case (_,0):
    println("X轴")
    fallthrough
case (0,_):
    println("Y轴")
case(_,_):
    println("象限里")

}





// fallthrough 关键字不能向下执行包含变量的分支

var point2 = (3,0)
switch point2{

case (0,0):
    println("原点")
    
case (let x, 0):
    println("x轴 x = \(x)")
    
case(0,let y):
    println("y轴 y = \(y)")
    
case(let x,let y):
    
    println("象限内 x = \(x) y = \(y)")
    
//case(let x,let y) while x != 0 && y != 0:
//    
//    println("象限内 x = \(x) y = \(y)")
//    
//default:
//    println("others")
}



// switch与区间运算符的结合使用
var number2 = 20
switch number2{

case 0...10:
    println("0...10")
case 11...20:
    println("11...20")
case 21...30:
    println("21...100")
default:
    println(">100")
}



//for ... in 与分支的结合使用
for value in 1...10 {

    if value == 2{
    
        break // 跳出循环
        //continue // 跳出本次循环
    }
    println(value)
}




/// for  in循环与switch结合使用的时候，break将首先被识别为switch的break语句（作用：结束当前分支）如果想在分支内结束循环，需要为循环设置名称，作为break的标记，从而打断当前循环
var tempString = "abcdefghigklmnopqrstuvwxyz"
tempName: for tempStr in tempString{
    println(tempStr)
    switch tempStr{
    case "a","e","i","o","u":
        //continue tempName;
        println("元音：\(tempStr)")
        break tempName
    default:
        println("非元音")
    }

}




// 结构体和类
// 在swift里面，结构体被做了强化，几乎所有的数据类型都是结构体
// 相同：1.都可以定义属性 2.都可以定义方法 3.都可以定义构造器 init
//      4.都可以遵守协议 5.延展
// 不同点：1.结构体是值类型，类是引用类型 2.类可以被继承 3.类可以使用类型判断
//        4.类可以使用析构器deinit 5.一个类可以有多个引用
/*
// 结构体
struct Resolution {
    // 定义属性
    var height = 0
    var width = 0
}

// 结构体自动为我们的构造生成了构造器  init
let resolution1 = Resolution(height: 11, width: 12)
resolution1.height
resolution1.width

// 类
class Video {

    var resolution = Resolution(height: 10, width: 10)
    var frameRate = 0.1
}
// 类不会自动生成构造器，需要自己实现
let video = Video()
video.resolution
video.frameRate



/**
*  值类型和引用类型的区别
*/
var newResolution = resolution1
newResolution.height = 20
newResolution.height
resolution1.height


var newVideo = video
newVideo.frameRate = 0.5
newVideo.frameRate
video.frameRate


/**
*  构造器
*/
struct ResolutionA {
    var height = 0
    var width = 0
    // 构造器 --- 系统自动生成self.属性名
    init (gao:Int,kuan:Int){
        self.height = gao
        self.width = kuan
    }
}
var resolutionA = ResolutionA(gao: 10, kuan: 10)
resolutionA.height
resolutionA.width



class VideoA {
    var resolution = Resolution(height: 10, width: 10)
    var frameRate = 0.1
    // 构造器会自动生成外部参数名，构造器内实现对属性的赋值操作
    init(frameRate:Double,resolution:Resolution){
        self.frameRate = frameRate
        self.resolution = resolution
    }
}
var videoA = VideoA(frameRate: 0.2, resolution: Resolution(height: 10, width: 10))



/**
*  属性分为 计算属性和存储属性
*/
// 存储属性：存储类和结构体里面的常量或变量
// 计算属性：不作为存储功能使用，计算属性本身提供get set方法间接的计算出属性的值

struct Point {
    var x = 0
    var y = 0
}

struct Size {
    var width = 0
    var height = 0
}


struct Rect {
    var point = Point(x: 0, y: 0)
    var size = Size(width: 100, height: 100)
    // 计算属性
    var center:Point{
        get{// 计算属性的get方法 --- 用于计算属性的值
            let centerX = point.x + size.width/2
            let centerY = point.y + size.height/2
            return Point(x: centerX, y: centerY)
        }
        // set方法里会自动生成newValue（代表外部传入的数）
        // 不实现set 只读属性
        set{// 实现平移变化 宽高不变
            
            let x = newValue.x - size.width/2
            let y = newValue.y - size.height/2
            point.x = x
            point.y = y
        }
    }
}
var rect = Rect(point: Point(x: 0, y: 0), size: Size(width: 200, height: 200))
rect.center
rect.center = Point(x: 200, y: 200)
rect.center.x
rect.point
*/

// 定义方法
struct ResolutionB {
    var width = 0
    var height = 0
    // 结构体中方法实现体内部默认不能对结构体属性做更改
    // 如果有属性更改需求 需要在方法定义前面使用mutating关键字进行修饰，类方法没有限制
    mutating func hello(){
            println("你好，大胖子")
        func dasini(){
            println("打死你，小鹏鹏")
        }
        dasini()
        width = 20
    }
    // 使用static关键字修饰的方法为静态方法，调用时使用结构体本身进行调用
    static func helloWorld(){
    
        println("你好，中国")
    }
    
}

var resouB = ResolutionB(width: 10, height: 10)
resouB.hello()
// 使用static关键字修饰的方法为静态方法，调用时使用结构体本身进行调用
ResolutionB.helloWorld()



class VideoB {
    var framRate = 0.1
    func dj(){
        println("哈哈")
    }
    // 使用class修饰的方法为类方法，使用类本身调用
    static func dj(){
        println("哈哈,笨蛋")
    }
    // 类型属性  只能是计算属性
    class var name:String {
        get{
            return "毛毛"
        }
    }
}
var videoB = VideoB()
videoB.dj()
// 使用class修饰的方法为类方法，使用类本身调用
VideoB.dj()