关闭

Swift 基础补充(1)

97人阅读 评论(0) 收藏 举报
分类:
1.Swift 是一种新的编程语言,用于编写 iOS,OS X 和 watchOS应用程序。Swift 结合了 C 和 Objective-C 的优点并且不受 C 兼容性的限制,Swift 是基于成熟而且倍受喜爱的 Cocoa 和 Cocoa Touch 框架

2.
  • 简单值(Simple Values)
  • 控制流(Control Flow)
  • 函数和闭包(Functions and Closures)
  • 对象和类(Objects and Classes)
  • 枚举和结构体(Enumerations and Structures)
  • 协议和扩展(Protocols and Extensions)
  • 泛型(Generics)

3.print("Hello, world!")

4.

简单值:使用let来声明常量,使用var来声明变量。let声明的常量只能赋值一侧 而var可以多出赋值

例如:
var myVariable =42 myVariable =50let myConstant =42
常量或变量的类型必须和所赋值的类型一样,可以不用明确的声明类型,因为赋值时编译器会自动推断类型,在上面的例子中,编译器推断出myVariable是一个整数(integer)因为它的初始值是整数。

如果没有初始值或没有足够的信息定义它的类型,那么可以再变量后面声明类型用冒号分开。
例:
let implicitInteger =70let implicitDouble = 70.0 let explicitDouble: Double =70
显示转化和隐式转化: 系统可以自己识别转换的类型为隐式转化,而需要认为的指定类型转换的为显示转化,否则系统自身无法处理类型转换。

把常量或变量转转换为字符串,再常量前加一个反斜杠
let apples =3let oranges =5let appleSummary ="I have\(apples) apples."let fruitSummary ="I have\(apples + oranges) pieces of fruit."

使用方括号[]来创建数组和字典,并使用下标或者键(key)来访问元素。最后一个元素后面允许有个逗号。

 varshoppingList = ["test1","test2","test3","test4 "]
        shoppingList[1] ="test5"
        print(shoppingList)
       
        var occupations = [
            "OM1" : "OM1",
            "OM0" : "OM1"
        ]
        occupations["OM2"] ="test3"
       print(occupations)

输出["test1", "test5", "test3", "test4 "]
["OM1": "OM1", "OM0": "OM1", "OM2": "test3"]
当key存在时直接替换掉key对应的值,若key不存在则添加一直新的key值

创建空数组字典
letemptyArray = [String]()
letemptyDic = [String:Float]()
print(emptyArray)
print(emptyDic)

如果类型已确定 :可直接这样声明
shoppingList = [] occupations = [:]

控制流
使用ifswitch来进行条件操作,使用for-inforwhilerepeat-while来进行循环。包裹条件和循环变量括号可以省略,但是语句体的大括号是必须的。

letsoureArray = ["OM1","OM2","OM3","OM4","OM5"]
        for soure in soureArray {
            if soure == "OM2" {
               print(soure)
            }
        }
       
        let soureArray2 = [10,11,12,13,14,15]
        var jiSuan = 0
        for value in soureArray2 {
            if value > 12 {
                jiSuan += value
                print(jiSuan)
            }
        }

if语句中,条件必须是一个布尔表达式——这意味着像if score { ... }这样的代码将报错,而不会隐形地与 0 做对比。 例如 ifvalue >12, 处理数值缺失使用iflet 。在类型后面加一个问号来标记这个变量的值是可选的 ,此时值可以为NIL
letoptainString:String? ="Hello"
        print(optainString ==nil)
       
        let optainName :String? ="John"
        var getting = "Hello!"
        if let name = optainName {
            getting = "Hello \(name)"
            print(getting)
        }

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

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

例 
letvegetable ="perper.OM2"
        switch vegetable {
        case "celery":
            print("Add some raisins and make ants on a log.")
        case "OM1", "OM2":
            print("That would make a good tea sandwich.")
        case let x where x.hasPrefix("perper"):
            print("Is it a spicy\(x)")
        default:
            print("Everything tastes good in soup.")
        }

switch 可以是if判断 可以加 或(多个值)

遍历字典可以使用for in  
 letnumbers = [
            "OM1":[2,3,4, 5, 6],
            "OM2":[7,8,9],
            "OM3":[10,11,12,13],
        ]
       
        var largest = 0
        for (kind, number) in numbers {
            for soures in number {
                if soures > largest {
                    largest = soures;
                    print(kind)
                    print(largest)
                }
            }
        }
kind 为遍历的key值 number 为value 集

使用ifswitch来进行条件操作,使用for-inforwhilerepeat-while来进行循环
 varn =2
       
while n < 100 {
            n = n *
2
        }
       
print(n)
       
       
var m = 2
       
repeat {
           m = m *
2
        }
while m < 100
       print(m)
 for 循环有两种方式 

 varfirstForLoop =0
        for i in 0..<4{
           firstForLoop += i
        }
        print(firstForLoop)
       
       
        var secondForLoop = 0
        for var i = 0; i < 4; ++i {
            secondForLoop += i
        }
       print(secondForLoop)

0..<4 i<4 效果一致 使用..<创建的范围不包含上界,如果想包含的话需要使用...

// 闭包 函数

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


func greet(name: String, foot:String) ->String{
            return "hello \(name), today eat\(foot)."
        }
        greet("xiaoMing", foot:"salad")
       print(greet("xiaoMing", foot:"salad"))

1. 使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示
funccalculates(scores: [Int]) -> (min:Int, max:Int, sum:Int) {
            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
            }
            return (min, max, sum)
        }
       
        let statistics = calculates([5,3,100,3 ,9])
        print(statistics.sum)
       print(statistics.1)

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

 funcsumOf(numbers:Int...) ->Int {
           varsum =0
            for number in numbers {
                sum += number
            }
            return sum
        }
        sumOf()
        sumOf(42,579,12)
        print(sumOf(42,579,12))



使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示。

 
        func calculates(scores: [Int]) -> (min:Int, max:Int, sum:Int) {
            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
            }
            return (min, max, sum)
        }
       
        let statistics = calculates([5,3,100,3 ,9])
        print(statistics.sum)
       print(statistics.1)
函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式:
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)
函数可以嵌套。被嵌套的函数可以访问外侧函数的变量,你可以使用嵌套函数来重构一个太长或者太复杂的函数。
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()


函数是第一等类型,这意味着函数可以作为另一个函数的返回值
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)
函数也可以当做参数传入另一个函数。
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
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, condition: lessThanTen)

var arr = [1,2,3,4,5]
        func famp(a : Int) ->Int{
            return a + 10
        }
       
        var arr2 = arr.map(famp)
        print(arr2)
       print(arr2 = (arr2))


 letmappedNumbers = numberss.map({numberssin3* numberss})
       print(mappedNumbers)
map为遍历使用 sort 为排序使用numbers为数组类型

let sortedNumbers = numberss.sort{$0 > $1}
print(sortedNumbers)


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:30877次
    • 积分:1158
    • 等级:
    • 排名:千里之外
    • 原创:85篇
    • 转载:9篇
    • 译文:1篇
    • 评论:0条