• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

Swift学习-01--基础部分

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

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


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
[Swift]LeetCode120.三角形最小路径和|Triangle发布时间:2022-07-13
下一篇:
swift网络编程入门应用:天气预报发布时间:2022-07-13
热门推荐
热门话题
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap