Swift 学习- 01 -- 基础部分

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())