Swift Programming Quick Start Notes - 1
2021-06-29 07:43:27
Swift
209

常量&变量

常量和变量的基本使用
import UIKit
let a : Int = 10
// 错误写法,当一个字段定义为常量时是不可以修改的
// a = 20
var b : Int = 20
// 因为b定义为变量,因此是可以修改的
b = 30

注意点: 1>在开发中优先使用常量,只有在需要修改时,在let改var.(数据更加安全) 2>常量的意思是:指向的对象可可用修改(指针不可修改)

//可以通过指针拿到对象,修改内部的属性
//在swift中创建对象.类()
let view : UIView = UIView(frame:CGRect(x: 0, y: 0, width: 100, height: 100))

//错误写法
//view = UIView()
view.backgroundColor = UIColor.red

//在swift中使用枚举:类型.具体类型
let btn : UIButton = UIButton(type: UIButtonType.contactAdd)
//btn = UIButton();
btn.center = CGPoint(x: 50, y: 50)
view.addSubview(btn)

数据类型

定义
// 定义一个Int类型的变量m,并且赋值为10
var m : Int = 10
// 定义一个Double类型的常量n,并且赋值为3.14
let n : Double = 3.14
类型推导
  1. 如果一个标识符在定义时有直接赋值,那么可以根据后面赋值的的类型,来推导出前面标识符的类型,那么这个时候,前面标识符的(:类型)类型可以省略
  2. 可以通过快捷键:option + 鼠标左键,来查看标识符类型
基本运算

swift中在进行基本运算时必须保证类型一致,否则会出错,相同类型之间才可以进行运算,因为Swift中没有隐式转换

let c = a + Int(b)
print(c)

var d = Double(a) + b
d = Double(a) * b

逻辑分支

if 语句
// 1>判断句可以不加()
// 2>判断句结果必须是一个真假值
let a = 20
let flag = a > 10

//示例一
//swift不存在非0即真这样的语法特性
if a != 0 {
    print("a有值")
}else{

}

// 示例二
let score = 87
if score < 60 {
    print("不及格")
}else if score < 70{
    print("及格")
}else if score < 90{
    print("良好")
}else if score <= 100{
    print("优秀")
}else{
    print("其他")
}
三目运算符
let age = 20
//swift中的string不再是对象,而是一个结构体
let result = age >= 18 ? "可以上网" : "回家去"
print(result)
guard
func onLine(age : Int) -> Bool {
    guard age >= 18 else {
        // 如果判断为假,会执行else
        print("回家找妈妈拿身份证")
        return false
    }

    //如果为真,继续执行
    print("可以留下来上网")
    return true
}
switch
// sex 为 0,表示男 sex 为1,表示女
let sex = 0;

//不用再写break打断
switch sex {
case 0:
    print("男")
case 1:
    print("女")
default:
    print("其他")
}

//switch的简单使用补充,如果想执行完case0再执行case1可以写fallthrough
switch sex{
case 0:
    print("男")
    fallthrough
case 1:
    print("女")
default:
    print("其他")
}

// 补充二:case中可以判断多个条件
// 如果想判断多个条件,可以通过分割
switch sex{
case 0,1:
    print("正常人")
default:
    print("其他")
}

//switch的特殊用法
//特殊用法一:switch可以判断浮点型
let a = 3.14

switch a {
case 3.14:
    print("π")
default:
    print("非π")
}

//特殊用法二:switch可以判断字符串
let m = 20;
let n = 25;

let opration = "/"
var result : Int

switch opration {
case "+":
    result = m + n
case "-":
    result = m - n
case "*":
    result = m * n
case "/":
    result = m / n
default:
        print("非法运算符")
}

//特殊用法三:switch 中可以判断区间
let score = 88
//区间:
//开区间:0~10 [0,10] swift:0...10
//闭区间:0~9 [0,10) swift:0..<10
switch score {
case 0..<60:
    print("不及格")
case 60..<70:
    print("及格")
case 70..<90:
    print("良好")
case 90..<100:
    print("优秀")
default:
    print("不合理的分数")
}
for循环
// 1.写法一:swift 3之前可以这样写
//for var i = 0;i<10;i++ {
//    print(i);
//}

// 2.写法二:区间for循环
for i in 0..<10 {
    print(i);
}

for i in 0...10 {
    print(i)
}

// 3.写法三:如果for循环中没有用到i,可以将i用_代理
for _ in 0..<10 {
    print ("hello world")
}
while循环
// 1> 不要()
// 2> 判断句必须有真假(Bool)
var a = 10;
while a < 20 {
    //swift3之前可以用a++
    //a++
    a += 1
    print("111")
}

//do while循环
//注意:在do while 循环中,不要再使用do.而是使用repeat代替do
repeat {
    a += 1
    print("222")
} while a < 30

字符串

OC和Swift中字符串的区别:
  • 在OC中字符串类型时NSString,在Swift中字符串类型是String
  • OC中字符串@"",Swift中字符串""
使用 String 的原因
  • String 是一个结构体,性能更高
  • NSString 是一个 OC 对象,性能略差
  • String 支持直接遍历
  • Swift 提供了 String 和 NSString 之间的无缝转换
使用
// 1.String的遍历
var str = "Hello, playground"
for s in str.characters {
    print(s)
}

// 2.String的拼接
// 1>两个字符串之间的拼接
let str1 = "my name is"
var str2 = " why"
str2 = str1 + str2

// 2>字符串和其他类型的拼接
let age = 18
let height = 1.88

//在字符串中拼接其他类型的常量/常量
//格式:\(变量/常量名字)
let str3 = "age is \(age), height is \(height)"

// 3>字符串的格式化
// 2:3 -> 02:03
let min = 2
let secode = 3
let time1 = "0\(min):0\(secode)"
//
let time2 = String(format:"%02d:%02d",arguments:[min,secode])

// 3.String的截取
let urlString = "www.520it.com"
// 提示:不要使用String方法截取.index非常不好创建
// urlString.subStringFromIndex(inde: Index)
// String转成NSString.只需要在String后面跟上:as NSString
let prefixString = (urlString as NSString).substring(to: 3)
let middelString = (urlString as NSString).substring(with: NSRange(location: 4, length: 5))
let subfixString = (urlString as NSString).substring(from: 10)

数组

数组分成:可变数组和不可变数组
  • 使用let修饰的数组是不可变数组
  • 使用var修饰的数组是可变数组
数组定义
// 数组:Array
// 可变数组 var修饰
// 不可变数组 let修饰

// 1.不可变数组
// 数组定义的写法一:
let names : Array<String> = ["why","yz","lmj","lnj"]
// names[0]

// 数组定义的写法二:
let names1 : [String] = ["why","yz","lmj","lnj"]


// 数组定义的写法三:类型推导
let names2 = ["why","yz","lmj","lnj"]

// 可变数组
// 数组定义的写法一:
var names3 : [String] = ["why","yz"]
names3.append("lmj")

//var names4: [String] = Array()
var names4:[String] = [String]()
names4.append("why")
数组操作(增删改,遍历)
// 定义一个可变数组
// Swift开始中,可以使用AnyObject代替NSObject
var names : [AnyObject] = [String]() as [AnyObject]

// 1.对数组的基本操作
// 1> 添加元素
names.append("why" as NSObject)
names.append("lmj" as NSObject)
names.append("lnj" as AnyObject)
names.append(18 as AnyObject)
names.append(1.88 as AnyObject)

// 2> 删除元素
names.removeLast()
names.remove(at:2)

// 3> 修改元素
names[0] = "yz" as AnyObject
names

// 4> 取出数组的值
names[2]

// 2.数组的遍历
// 1> 通过下标值遍历
for i in 0..<names.count {
    print(names[i])
}

// 2> for in 方式
for item in names{
    print(item)
}

for i in 0..<2 {
    print(names[i])
}

for item in names[0..<3]{
    print(item)
}

// 3. 数组的合并
let array1 = ["why","+86 110",18] as [Any]
let array2 = [1.88,"china"] as [Any]
let array3 = array1 + array2

let names1 = ["why","yz","lmj"]
let ages = [18,20,25]
var array4 = [AnyObject]()
for item in names1 {
    array4.append(item as AnyObject)
}

for item in ages{
    array4.append(item as AnyObject)
}

字典

字典基本操作
// 字典的类型:Dictionary
// 不可变字典:let修饰
// 可变字典:var修饰

// 不可变字典
let dict1 : Dictionary<String,AnyObject> = ["name":"why" as AnyObject,"age":18 as AnyObject]
//dict1["height"] = 1.88

// 2>方式二:
let dict2: [String : AnyObject] = ["name" : "why" as AnyObject, "age" : 18 as AnyObject]

// 可变字典
// 1> 方式一(不常用):
var dict4 = Dictionary<String,AnyObject>()
// 2> 方式二:
var dict5 = [String : AnyObject]()
// 3> 方式三:
var dict6 = ["name":"why" as AnyObject, "age" : 18 as AnyObject]
对字典的操作(增删改,遍历)
// 定义一个可变字典
var dict = [String : AnyObject]()

// 1.对字典的基本操作
// 1> 增加元素
dict["name"] = "why" as AnyObject
dict["age"] = 18 as AnyObject
dict["height"] = 1.88 as AnyObject
dict["weight"] = 60.0 as AnyObject

// 2> 删除元素
//dict.removeAll()
dict.removeValue(forKey: "weight")

// 3> 修改元素
// 注意:通过该方式类修改元素,如果有对应的键,则修改.如果没有对应的键,则添加元素
dict["name"] = "lmj" as AnyObject


// 4> 取出元素
dict["age"]

// 2. 对字典的遍历
// 1> 遍历字典中的所有键
for key in dict.keys{
    print(key)
}

// 2> 遍历字典中所有的值
for value in dict.values {
    print(value)
}

// 3> 遍历所有的键值对
for (key,value) in dict {
    print(key)
    print(value)
}

// 3.字典的合并
let dict1 = ["name":"why","age":18] as [String : Any]
var dict2 = ["phoneNum":"+86 110", "height" : 1.88] as [String : Any]

// 注意:字典无论类型是否一致,都不可以直接相加合并
// let dict3 = dict1 + dict2
for (key1,value1) in dict1{
    dict2[key1] = value1
}

元组

元组是Swift中特有的,它是一种数据结构,在数学中应用广泛,类似于数组或者字典,可以用于定义一组数据。

元组的定义与使用
// 定义元组
// 方式一:
let a = ("why",18,1.88)

// 方式二:
let b = (name : "why",age : 18, height : 1.88)

// 方式三:
let (name , age , height) = ("why", 18 , 1.88)

// 元组的使用
let error = (404,"Not Found")
error.0
error.1

let error1 = ( errorCode: 404 , errorInfo : "Not Found")
error1.errorCode
error1.errorInfo

let (errorCode1, errorInfo1) = (404,"Not Found")
errorCode1
errorInfo1

可选类型

  • 在OC开发中,如果一个变量暂停不使用,可以赋值为0(基本属性类型)或者赋值为空(对象类型)
  • 在swift开发中,nil也是一个特殊的类型.因为和真实的类型不匹配是不能赋值的(swift是强语言)
  • 但是开发中赋值nil,在所难免.因此推出了可选类型

可选类型时swift中非常难理解的一个知识点,暂时先了解,多利用Xcode的提示来使用,随着学习的深入,慢慢理解其中的原理和好处

/**************方式一**************/
// 1>方式一:optional<String>
/*
class Person {
    // 定义属性
    var name : Optional<String>
}
*/

var name : Optional<String>

// 给可选类型赋值
name = "why"
// 错误写法
// let info = "my name is" + name

// 打印可选类型:Optional("why")
print(name)

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

let info = "my name is " + name!


/*************方式二**************/
// 2>方式二:语法糖
// let phoneNum : Optional<String>
var phoneNum : String?
phoneNum = "+86 110"


// 使用注意:如果一个可选类型中没有值,强制解包会报错
// 在强制解包之前,最好对可选类型进行判断.如果有值,再进行解包
if phoneNum != nil {
    let phoneInfo = "My PhoneNum is " + phoneNum!
}

// 可选绑定:判断phoneNum是否有值
// 1>如果没有值,则直接跳过{}
// 2>如果有值,将可选类型进行解包,并且将解包后的值赋值给tempPhoneNum
if let tempPhoneNum = phoneNum {
    print(tempPhoneNum)
}
可选类型应用场景之一:让代码更加严谨
// 通过该方法创建的URL,可能有值,也可能没有值
// 错误写法:如果返回值是nil时,就不能接收了
let url : NSURL = NSURL(string: "www.520it.com")

// 正确写法:使用可选类型来接收
let url : NSURL? = NSURL(string: "www.520it.com")

// 通过url来创建request对象
if let tempUrl = url {
    let request = NSURLRequest(URL: tempUrl)
}

函数

使用方法
// 1.没有参数,也没有返回值的函数
func about() -> Void {
    print("手机型号是iPhone6s Plus玫瑰金")
}
about()
//注意,如果一个函数没有返回值m那么:(-> Void)省略
func about1() {
    print("手机型号是iPhone6s Plus玫瑰金")
}
about1()

// 2.有参数,没有返回值的函数
//- (void)callPhone:(String *)phoneNum
func callPhone(phoneNum: String){
    print("打电话:" + phoneNum)
}
callPhone(phoneNum: "+86 110")


// 3.没有参数,有返回值的函数
func readMessage() -> String {
    return "吃饭"
}
print(readMessage())


// 4.有参数,有返回值的函数
// 注意:如果有多个参数,则参数使用,分割
func sum(num1 : Int, num2 : Int) -> Int {
    return num1 + num2
}

sum(num1: 12, num2: 20)