print("世界,你好")

var myVariable = 42

myVariable = 50

let myConstant = 42

let implicitinteger = 70

let  fffffff = 70.0

let exnfjenb: Double = 80

let changliang: Float = 4

var frewf: Double = 5

print(changliang)

let  label = "你哦好的"

let width = 94

let widthlabel = label + String(width)

let label2 = "1234565"

let heught: Int = 88

let all = String(heught) + label2

let apples = 3

let oranges = 5

let appleCount = "I have \(apples) apples"

let  fruitCount = "i have \(oranges) oranges"

print(fruitCount)

let fudina: Double = 402.0840000

let helloStr = "nihao de \(fudina) nihao"

print(helloStr)

var shoplist = ["apple","oranges","banage","blueanj"]

shoplist[1] = "bbbbbb"

shoplist .removeAll()

if shoplist.count > 2 {

    print(shoplist[1])

}else{

    print("数组为空")

}

var dictionary = ["aaa":"AAA","bbb":"BBB"]

var emptyArray = [String]()

let individualScores = [12,23,34,45,56]

var teamScores = 0

for score in individualScores {

    if score > 20 {

        teamScores += 3

    }else{

        teamScores += 1

    }

}

print(teamScores)

// 在 if 语句中  条件必须是一个bool值,这意味着 判断不会隐形的与 0 做对比

// 你可以一起使用 if 与 let 来处理值确实的情况,这些值将由可选值来代表

// 一个可选值是一个具体的值或者是 nil 以表示值缺失,在类型后面加一个问号来标记这个变量的值是可选的

var optionalName: String? = "John Appleseed"

optionalName = nil

var greeting = "Hello!"

if let name = optionalName {

    greeting = "Hello, \(name)"

}else{

    greeting = "Hello!,(杜露茜)"

}

print(greeting)

// 如果变量的可选值是nil,条件会判断为false , 大括号中的代码会被跳过,如果不是nil ,会将值解包并赋给 let 后面的常量,这样代码中就可以使用这个值了

// 还有一种处理可选值的方法就是通过使用 ?? 操作符来提供一个默认值,如果可选值缺失的话,可以使用默认值来代替

let nickName: String? = "dingzhiije"

let fullName: String = "DingZhijie"

let myName = "my name is \(nickName ?? fullName)"

print(myName)

// switch 支持任意类型的数据以及各种比较操作--不仅仅是整数以及测试相等

let vegetrabel = "red pepper"

switch vegetrabel {

case "red pepper":

    print("red")

case "black":

    print("black")

default:

    print("no")

}

// swift 中 运行 switch 的时候 运行完匹配完的子句之后,程序会退出 switch 语句,并不会向下运行,所以不需要再每个子句之后写 break;

let interestingNumbers = [

    "Prime":[2,3,5,7,11,13],

    "Fibonacci":[1,1,2,3,5,8],

    "Square":[1,4,9,16,25]

]

// 遍历字典

var largest = 0

var largestKey: String = ""

for (kind,numbers) in interestingNumbers {

    for number in numbers {

        if number > largest {

            largest = number;

            largestKey = kind

        }

    }

}

print(largest)

print(largestKey)

var num = 0

var addNum = 0

while num < 101 {

    addNum = addNum + num

    num += 1

}

print(addNum)

// 循环条件也可以在结尾循环一次,至少会循环一次

// repeat 循环语句

var m = 2

repeat { // 重复

    m = m * 2

} while m < 100

    print(m)

// 可以再循环中使用 ..< 来表示范围

var total = 0

for i in 0 ..< 4 {

    total += 1

    print(i)

}

// a ..< b 的范围是  大于等于 a , 但是小于 b

// a ... b 的范围是  大于等于 a , 而且小于等于 b

// 这是因为 ..< 创建的范围不包含上界, 但是 ... 创建的范围包含上界

// 使用 func 来声明一个函数,使用名字和参数来调用函数, 使用 -> 来指定函数的返回值的类型

func green(person: String, day: String) -> String {

    return "hello \(person), today is \(day)"

}

print(green(person: "houdecheng", day: "2017-5-5"))

func eat(person: String, eatWhat: String) -> String {

    return "hello, \(person), my today wat\(eatWhat)"

}

print(eat(person: "houdehcneg", eatWhat: "danchaofan"))

// 默认情况下,函数使用它们的参数名称作为它们参数的标签, 在参数名称前面可以自定义参数标签, 或者使用 _ 表示不使用参数标签

func ceshi( _ person: String,on day: String) -> String{

    return "hello, \(person), today is \(day)"

}

print(ceshi("houdehceg", on: "2017-5-5"))

// 使用元组让函数返回多个值,元组的元素可以用名称或者数字来表示

func yuanzuceshi(scores: [Int]) -> (min: Int,max: Int, sum: String){

    var min = scores[0]

    var max = scores[0]

    var sum = 0

    for score in scores {

        if score > max {

            max = score

        }else if score < min{

            min = score

        }

        sum += score;

    }

    let sumStr: String = String(sum)

    return (min,max,sumStr)

}

print(yuanzuceshi(scores: [15,54,45,54,78,15,6,98]))

// 函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式

func kebiancanshu(numbers: Int...) -> Double {

    var sum = 0

    for i in numbers {

        sum += i

    }

    let pingjunzhi: Double = Double(sum)/Double(numbers.count)

    return pingjunzhi

}

print(kebiancanshu(numbers: 4,3,5,6))

// 函数可以嵌套 , 被嵌套的函数可以访问外侧函数的的变量 你可以使用嵌套函数来重构一个太长或者太复杂的函数

func returnFifteen() -> Int{

    var y = 10

    func add(){

        y += 5

    }

    add()

    return y

}

print(returnFifteen())

// 函数是第一等类型  这意味着函数可以作为另一个函数的返回值

func addOne(number: Int,str: String) -> Int{

    return Int(str)! + number

}

func makeIncrmenter() -> ((Int,String) -> Int) {

    return addOne(number:str:)

}

var increment = makeIncrmenter()

print(increment(88,"44"))

// 函数也可以当做参数传入另一个函数

func hasAnyMatches(list: [Int] , condition: (Int) -> Bool) -> Bool{

    for item in list {

        if condition(item) {

            return true

        }

    }

    return false

}

func lessThanTen(number: Int) -> Bool {

    return number < 10

}

let numbers = [20,19,7,12]

let dictionary2: Dictionary = ["1":45,"2":43]

print(hasAnyMatches(list: numbers, condition: lessThanTen(number:)))

// 函数实际上是一种特殊的闭包, 他是一段之后能调用的代码.闭包中的代码能访问闭包所创建作用域中能得到的变量和函数,即使闭包是在一个不同的作用域被执行的 - 可以使用 {} 来创建一个匿名闭包, 使用 in 将参数和返回值类型与闭包函数体进行分离

print(numbers.map { (number: Int) -> Int in

    let result = 3 * number

    return result

})

// 有很多种创建更简洁的闭包的方法,如果一个闭包的类型已知,比如作为一个回调函数,你可以忽略参数的类型和返回值,单个语句闭包会把它语句的值当做返回值返回

//let mappedNumbers = numbers.map({ number in 3 * number })

//print(mappedNumbers)

let mappendNumbers = numbers.map { (number: Int) -> Int in

    let result = 3 * number

    return result

}

print(mappendNumbers)

// 可以通过参数的位置而不是参数的名称来引用参数 -- 这个方法在非常短的闭包中非常有用,当一个闭包作为最后一个参数传给函数的时候,他可以直接在括号后面,当一个闭包是传给函数的唯一参数,你可以完全忽略括号

let sortedNumbers = numbers.sorted { (a, b) -> Bool in

    a > b

}

print(sortedNumbers)

// 字典的排序

let dicSorted = dictionary2.sorted { (a, b) -> Bool in

    a.value > b.value

}

print(dicSorted)

// 对象和类

// 使用 class 和类名创建一个类. 类中属性的声明和变量,变量声明一样,唯一的区别就是他们的上下文是类,同样,方法核函数声明也一样

class Shape {

    var numberOfSides = 0

    func simpleDescription() -> String {

        return "A shape with \(numberOfSides) sides."

    }

}

// 要创建一个类的实例,在类名后面加上括号,使用点语法来访问实例的属性和方法

var shape = Shape()

shape.numberOfSides = 7

print(shape.simpleDescription())

class MyDay{

    let day = "2017年 5月 5号"

    func prienDay(day: String) -> String {

        return "今天是 \(day)"

    }

}

var mydays = MyDay.init()

print(mydays.prienDay(day: mydays.day))

// 这个版本的 Shape 缺少了一些重要的东西,一个构造函数来初始化实例,使用 init 来创建一个构造器

class NamedShape{

    var numberOfSides: Int = 0

    var name: String

    init(name: String) {

        self.name = name

    }

    func simpleDecription() -> String {

        return "A shape with \(numberOfSides) \(name) sides"

    }

}

var nameShpe = NamedShape.init(name: "houdehcneg")

print(nameShpe.simpleDecription())

// 注意 self 被用来区别实例变量,当你创建的时候,像传入函数参数一样给类擦混入构造器的参数,每个属性都需要赋值 -- 无论是通过声明 (例如 numberOfSides) 还是通过构造器 (例如 name)

// 如果你需要在删除对象之前进行一些清理工作, 使用 deinit 创建一个拆构函数

// 子类的定义方法是在他们的类名后面加上父类的名字,用冒号分割,创建类的时候并不需要一个标准的跟类,所以你可以忽略父类

// 子类如果需要重写父类的方法,需要用 override 标记 -- 如果没有添加 override  就去重写父类的方法编辑器会报错,编辑器同样会检测 override 标记的方法是否确实在父类中

class Square: NamedShape{

    var sideLength: Double

    init(sideLength: Double,name: String) {

        self.sideLength = sideLength;

        super.init(name: name)

        numberOfSides = 4

    }

    func area() -> Double {

        return sideLength * sideLength

    }

    override func simpleDecription() -> String {

        return "A squre with side of length \(sideLength) \(numberOfSides)"

    }

}

let test = Square.init(sideLength: 5.2, name: "my test squre")

print(test.area())

print(test.simpleDecription())

class Circle: NamedShape{

    var banjing:Double

    init(banjing: Double,name: String) {

        self.banjing = banjing

        super.init(name: name)

    }

    func area() -> Double {

        return self.banjing

    }

    override func simpleDecription() -> String {

        return "\(banjing),\(numberOfSides),\(name)"

    }

}

var circle = Circle.init(banjing: 2.0, name: "dinngzhijie")

print(circle.area())

print(circle.simpleDecription())