swift基础小结1

swift基础小结

一、swift初体验
1.导入框架
  1.1  import UIKit 
2. 定义标识符
  2.1  定义标识符必须告知系统该标识符是一个变量还是一个常量
  2.2  let修饰常量,var修饰变量
3.语句结束
  3.1  一行中只有一条语句,那么:分号可以省略
4.打印内容
  4.1  let a : Int = 20; print(a);print("hello word")

二、常量&变量的使用注意事项
1.开发中优先使用常量
2.常量的本质是保存的内存地址不可以修改,但是可以通过内存地址拿到对应的对象,修改对象内部的属性

三、数据类型
1.整形&浮点型
  1.1 Int
  1.2 Double
2.类型推导
  2.1 如果定义一个标识符时,有直接给该标识符从赋值,那么会根据赋     值的类型推导出前面标识符的类型
  2.2 可以按住option+鼠标左键  产看数据类型
3.swift中的基本运算
  3.1 相同类型才可以进行运算
  3.2 Double(m)
  3.3 Int(n)

四、逻辑分支
1. if分支
   1.1  if后面的小括号可以省略
   1.2 没有非0即真运算
2. else if 
3. 三目运算
4. guard
    4.1 guard 判断句 else { return/break/continue } 语句块
5. switch
   5.1 switch基本用法:1>switch后面的()可以省略  
                     2>case结束后可以省略break
   5.2 补充:1> fall through  2>case后面可以判断多个条件,多个条件以,分割
   5.3 switch判断浮点型
   5.4 switch判断字符串
   5.5 switch判断区间

五、循环
1. for循环
    1.1 var i = 0; i < 10; i++ {}
    1.2 for i in 0..<10 {}
    1.3 for _ in 0..<10 {}
2. while循环
   2.1 while后面的()可以省略
   2.2 while后面的判断句没有非0即真
3. downhill循环
   3.1 do换成repeat

for 循环OC与Swift对比

// OC写法
//for (int i = 0; i < 10; i++) {
//    NSLog(@"%d", i);
//}

// Swift写法
// for后面的()可以省略
// 1> for循环的基本写法
for var i = 0; i < 10; i++ {
    print(i)
}

// 2> for循环的forin写法
for i in 0 ..< 10 {
    print(i)
}

// 2> for循环的forin写法(特殊)
// 在swift中如果一个标示符不需要使用,可以使用_来代替
for _ in 0...9 {
    print("hello world")
}

While循环与downhill循环 OC与swift使用的区别

// OC写法
//while (a) {
//
//}

// swift写法
// 1> while后面的()可以省略
// 2> while后面的判断没有非0即真

while a > 0 {
    print(a)
    a -= 1
}

// 2> for循环的forin写法(特殊)
// 在swift中dowhile循环需要写成 repeat while
repeat {
    print(a)
    a += 1
} while a < 10

字符串
swift中使用String的原因

  1. String是一个结构体,性能更高
    2.NSString是一个OC对象,性能略差
  2. String支持直接遍历
  3. Swift提供了String和NSString之间的无缝转换
//  1.定义字符串
let opration = "+"

// 2.遍历字符串
let str = "hello world"
for c in str.characters {
    print(c)
}

// 3. 字符串的拼接
// 3.1 两个字符串之间的拼接
let str1 = "小明"
let str2 = "爱玩游戏"

//NSString .stringByAppendingFormat(@"%@%@", str1, str2)
let str3 = str1 + str2


// 3.2 字符串和其它标识符之间的拼接
let name = "wxn"
let age = 18
let height = 1.88

let info = "my name is wxn, my name is 18, my height is 1.88"
let newInfo = "my name is \(name), my age is \(age), my height is \(height)"

// 3.3 拼接字符串时,字符串的格式化
// eg:显示时间,0占位
let min = 2
let second = 18
let timeString = "\(min):\(second)"
String(format:"%02d:%02d", arguments:[min,second])


// 4. 字符串的截取
let urlString = "www.520swift.com"
// 将String类型转换成NSString类型 (string as NSString)
let header = (urlString as NSString).substringToIndex(3)
let middle = (urlString as NSString).substringWithRange(NSMakeRange(4, 8))
let footer = (urlString as NSString).substringFromIndex(13)

数组
数组(Array)是由一串有序的由相同类型元素构成的集合
数组中的集合元素是有序的,可以重复出现

let array = ["why", "qe", "wewe", "we", "dd", "ase"]

// 定义可变数组:使用var修饰标识符定义出来的数组就是可变数组
var arrayM = [String]()

// 对可变数组的基本操作
// 2.1 添加元素
arrayM.append("qwre")
arrayM.append("df")
arrayM.append("vc")

// 2.2 删除元素
arrayM.removeAtIndex(0)
arrayM

// 2.3 修改元素
arrayM[0] = "asdsd"
arrayM

// 2.4 取出某一个元素
arrayM[1]

// 3. 数组的遍历
// 3.1 根据下标值进行遍历
for i in 0..<arrayM.count {
    print(arrayM[i])
}

// 3.2 直接遍历数组中的元素
for name in array {
    print(name)
}

// 3.3 遍历数组中前两个元素
for i in 0..<2 {
    print(array[i])
}

for name in array[0..<2] {
    print(name)
}

// 4.数组合并
let resultArray = array + arrayM
// 注意:相同类型的数组才可以进行合并,不同类型不能相加合并

字典的使用

// 1.定义字典

// 1.1 定义不可变字典:用let修饰
// 系统会自动判断后面的[]中存放的是键值对,还是一个一个的元素
let dict = ["name":"lmj", "age":18, "height":1.82]
// 1.2 定义可变字典:用var修饰
// var dictM = Dictionary<NSString, NSObject>()
// AnyObject: 一般指定类型 NSObject:一般用于创建对象
// var dictM = [String: AnyObject]
var dictM = [String: AnyObject]()

// 2. 对可变字典的基本操作
// 2.1 添加元素
dictM["name"] = "jsl"
dictM["age"] = 18
dictM["height"] = 1.89
dictM["weight"] = 80
dictM

// 2.2 删除元素
dictM.removeValueForKey("weight")
dictM

// 2.3 修改元素
// 区别:如果字典中已经有了对应的key,那么会直接修改原来key中保存的value
// 如果字典中没有对应的key,那么添加对应的key/value
dictM["name"] = "lj"
dictM

// 2.4获取某一个元素
dictM["age"]

// 3.遍历字典
// 3.1 遍历字典中所有的key 
for key in dictM.keys {
    print(key)
}

// 3.2 遍历字典中所有的value
for value in dictM.values {
    print(value)
}

// 3.3 遍历所有的键值对
for (key, value) in dictM {
    print(key)
    print(value)
}

// 4.合并字典
// 即使类型一致也不能相加进行合并
var dict1 = ["name" : "why", "age" : 18]
var dict2 = ["height" : 1.89, "phoneNum" : 12233242234]

for (key, value) in dict2 {
    dict1[key] = value
}

dict1

元祖

  1. 它是一种数据结构,在数学中应用广泛
    2.类似于数组或字典
    3.可以用于定义一组数据
    4.组成元祖类型的数据可以称为“元素”

// 1. 使用数组定义一组数组
let arraya = ["why", 18, 1.89]
arraya[0]
arraya[1]

// 2. 使用字典定义一组数据
let dicta = ["name" : "sd", "age" : 13]
dicta["name"]
dicta["age"]

// 3. 使用元祖定义一组数据(一般作为方法的返回值)
// 3.1 元祖最基本写法
let info = ("why", 18, 1.89)
info.0
info.1
info.2

// 3.2 可以给元祖的每一个元素起一个别名
let info1 = (name : "why", age : 18, height : 1.88)
info1.name
info1.0
info1.age
info1.height

// 3.3 元祖中元素的别名就是元祖的名称
let (name, age, height) = ("why", 18, 1.88)
name
age
height

可选类型
概念:

  1. 在OC开发中,如果一个变量暂时不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
  2. 在swift开发中,nil也是一个特殊的类型,因为和真实的类型不匹配是不是赋值的(swift是强类型语言)
  3. 但是开发中赋值nil,在所难免,因此推出了可选类型
    可选类型的取值
  4. 可选
  5. 不可选
// swift中有规定:对象中的任何属性在创建对象时,都必须有明确的初始值
// 1. 定义可选类型
// 1> 方式一:常规方式(不常用)
//var name : Optional<String> = nil
// 2> 方式二:语法糖(常用)
var name : String? = nil

// 2. 给可选类型赋值
name = "ks"

// 3. 取出可选类型中的值
// 可选类型 + ! : 强制解包
print(name!)

// 4. 注意强制解包是非诚危险的操作,如果可选类型为nil,强制解包会崩溃
// 建议:在强制解包前,先对可选类型进行判断,判断是否为nil
if name != nil {
    print(name!)
}

// 5. 可选绑定
// 1> 判断name是否有值,如果没有值,直接不执行{}
// 2> 如果name有值,系统会自动将name进行解包,并且将解包后的结果,赋值给tempName

// 写法一:不常用
if let tempName = name {
    print(tempName)
}

// 写法二:常用
if let name = name {
    print(name)
}


//// 可选类型的应用场景
// 通过一个字符串创建一个NSURL对象
let url = NSURL(string: "http://www.baidu.com")

// 根据url创建NSURLRequest对象
if let url = url {
    let request = NSURLRequest(URL: url)
}

函数

  1. 函数相当于OC中的方法
  2. 函数的格式如下
    fun 函数名(参数列表) -> 返回值类型 {
    代码块
    return 返回值
    }
    2.1 func 是关键字,多个参数列表之间可以用逗号(,)分隔,也可以没有参数
    2.2 使用箭头“->”指向返回值类型
    2.3 如果函数没有返回值,返回值为Void,并且"-> 返回值类型"部分可以省略
// 1. 没有参数没有返回值得函数
func about() -> Void {
    print("iPhone7")
}
about()

func about1() -> Void {
    print("iPhone8")
}
about1()


// 2. 没有参数有返回值得函数
func readMessage() -> String {
    return "吃饭了吗?"
}
print(readMessage())

// 3. 有参数没有返回值得函数
func callPhone(phoneNum: String) {
    print("打电话给" + phoneNum)
}

callPhone("+86 234323242")

// 4. 有参数有返回值得函数
func sum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}

sum(20, num2: 30)

函数使用注意事项

func sum(num1 num1: Int, num2: Int) -> Int {
    return num1 + num2
}

sum(num1: 20, num2: 30)
// 函数使用注意事项
// 注意一:内部参数和外部参数
// 内部参数:在函数内部可以看到的参数就是内部参数,默认情况下所有的参数都是内部参数
// 外部参数:在函数外部可以看到的参数就是外部参数,默认情况下从第二个参数开始的所有的参数即是内部参数又是外部参数
// 如果希望第一个参数也是外部参数,可以在标识符前给该参数添加一个别名

// 注意二:swift中的默认参数
func makeCoffee(coffeeName: String = "雀巢") -> String {
    return"制作了一杯\(coffeeName)咖啡"
}

makeCoffee("拿铁")
makeCoffee("卡布奇诺")
makeCoffee("猫屎")
makeCoffee()


// 注意三:可变参数
func sum(num: Int...) -> Int {
    var result = 0
    for n in num {
        result += n
    }
    return result
}

sum(18, 20, 23)
sum(23, 45, 2, 3, 231)

// 注意四:指针类型
// m、n作交换
var m = 10
var n = 30

/*
func swapNum(var m: Int, var n: Int) {
    let tempNum = m
    m = n
    n = tempNum
}
swapNum(m, n: n)
 */


// 如果想传递值,需要在参数前加一个“inout”
func swapNum(inout m: Int, inout n: Int) {
    let temp = m
    m = n
    n = temp
}
swapNum(&m, n: &n)
print("m:\(m), n:\(n)")


// 注意五:函数的嵌套使用
func test() {
    func demo () {
        print("demo")
    }
    print("test")
    demo()
}

test()

推荐阅读更多精彩内容