[IOS开发]Swift语法快速入门

最新推荐文章于 2024-05-15 10:57:44 发布

chencision

最新推荐文章于 2024-05-15 10:57:44 发布

阅读量391

点赞数

文章标签： ios ios开发 Swift

本文链接：https://blog.csdn.net/baidu_34595620/article/details/77985057

版权

普通变量

var i = 100
var i:Int = 100
var i:String = "hello"
let c=i+i //c不能改变

可选类型

//可选类型 任何已知类型后面紧跟？ 即可代表 可选类型 如 Int？
var str = “Hello”
var num:Int? = str.toInt()  //nil 表示 值缺失

//强制解析：在变量或者常量后面添加 ！  注意：必须可选类型的变量和常量缺失油脂的时候才解析成功
var num1: Int? = 10
var num2: Int? = 20
if num1 != nil && num2 != nil{
    let sum = num1! + num2!
}else{
    print(“num1 或者 num2 为 nil ，不能强制解析")
}

//可选绑定：可以用在 if 和 while 语句中来对可选类型的值进行判断并把值赋给一个常量或者变量
var str3: String! = “SWIFT”
if var tmp = str3{
    
}else{
    //str3的值为nil 不能解析
}

//隐式解析可选类型 ： 在已有类型后添加! 如 Int！ 适用于被赋值之后不会重新变为nil的变量
var possibleStr: String! = “aaa”
print(possibleStr)

字符串链接

var a = "sat"
var b = "we"
var c = a+b
c="\(a)\(b)"

数组定义

var arr = [12,34,"hello",str]
var arr = String[]()
var arr:[Any] = [“sw”,12,[“ios”:23],Fruit(name:”aaa”)]
var arr:[Any] = [Fruit(name:”bbb"),Fruit(name:”aaa")]

dictionary 字典

var dict = ["name":”lalal","age":"16"]
dict["sex"]="Female"
print(dict)
print(dict["name"])

for&while循环

var arr = String[]()

for index in 0..100{
     arr.append("Item\(index)")
}
print(arr) //0-99

for value in arr{
     print(value)
}

for (key,value) in dict{
     print("\(key),\(value)")
}

var i = 0
while i<arr.count{
     print(arr[i])
     i++
}

条件流程

var arr = String[]()

for index in 0..100{
     arr.append("Item\(index)")
}
print(arr) //0-99

for value in arr{
     print(value)
}

for (key,value) in dict{
     print("\(key),\(value)")
}

var i = 0
while i<arr.count{
     print(arr[i])
     i++
}

函数

func sayHello(name:String){
     print(name)
}

sayHello("play")

var fun = sayHello
fun("Zzz")

//->()设置返回值
func getNums()->(Int,Int){
     return (2,3)
}
let(a,b ) = getNums()

//可变参数：在参数类型后面添加 … 表示该参数可以接受多个参数值
func sum(numbers: Int…) -> Int{
    var total: Int = 0
    for num in numbers{
        total += num
    }
    print(total)
    return total
}

//In-Out 形参
func swap(inout a: Int , inout b: Int){
    let tmp = a
    a = b
    b = tmp
}
var a:Int = 1
var b:Int = 3
swap(&a,&b)

函数作为参数形式
func multiplyTwoIns(a: Int, b: Int) -> Int{
     return a*b
}
//var math: (Int, Int) -> Int = multiplyTwoIns
func printRES(math: (Int,Int) -> Int, a:Int,b:Int){
     print(math(a,b))
}
printRES(multiplyTwoIns,3,5)

函数作为返回值类型
func squre(num: Int)-> Int{
     return num*num
}
func cube(num: Int)-> Int{
     return num
}
func getMathFunc(#type: String) -> (Int) -> Int{
     switch(type){
         case "squre":
         return squre 
         default:
              return cube
     }
}

var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

嵌套与闭包

//嵌套
func getMathFunc(#type: String) -> (Int) -> Int{
    func squre(num: Int)-> Int{
     return num*num
    }
    func cube(num: Int)-> Int{
     return num
    }
     switch(type){
         case "squre":
         return squre 
         default:
              return cube
     }
}

var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

//闭包  { (形参列表) -> 返回值类型 in 可执行表达式 }
func getMathFunc(#type: String) -> (Int) -> Int{
     switch(type){
         case "squre":
         return {(num: Int) -> Int in
                 return num*num   
        }
         default:
              return {(num: Int) -> Int in
                 return num*num*num  
        }
     }
}
 
var mathFunc = getMatrhFunc(type:"other")
print(mathFunc(5))

//利用上下文推断
var squre: (Int) -> Int = {(num) in return num*num}
var squre: (Int) -> Int = {num in return num*num}

//省略形参名，通过$0,$1 ...来引用第一个、第二个参数
var squre: (Int) -> Int = {$0*$0}
print(squre(3))

//尾随闭包
var result: Int = {
    var result = 1
    for i in 1…$1{
        result *= $0
    }
    return result
}(4,3)
print(result)

function someFunction(num: Int , fn:(Int) -> ()){

}
someFunction(20,{})
//使用尾随闭包调用函数的格式
someFunction(20){}

枚举

enum Season{
    case spring = 1，Summer,Fall,Winter
}
var weather:Season
//weather = Season.Summer
weather = .Summer
print(Season.spring.rawValue)

//原始值
/*
enum 枚举名：原始值类型{
    case 枚举值 = 原始值
}
*/  

var play:[Pler]

//关联值
enum Planet{
    case Earth(weight: Double , name: String)
    case Mars(den: Double, name: String,weight:Double)
}
var p1 = Planet.Earth(weight: 1.0,name:”diqiu”)
var p2 = Planet.Mars(3.95,”jingxing”,1.0)

switch(p2){
//将关联值绑定到变量或者常量来提取
    case Planet.Earth(var weight, var name):
        print(weight)
    case let Planet.Mars(den: d, name:b,weight:w):
        print(d)
}

面对对象

<strong>class Hi{
     func say(){
          print("Hi")
     }
    final play(){} //不能被继承
}
var hi=Hi()
hi.say()

class Hello:Hi{
     var _name:String
     
     //构造
     init(name:String){
          self._name = name
     }
     
     //重写
     override func say(){
         print(self.name) 
     }
    //方法内参数出第一个默认为外部参数名 需要在参数名前加 _ 来取消
    func eat(参数){

    }

    //类方法
    class func wwat(){
    
    }
}
var h = Hello(name:"AAA")
h.say()

//结构体
struct JKReact{
    //mutating func …… 为可变方法 可以更改实例化的存储属性
    mutating func moveByX(){

    }
}

//多态
向上转型
父类调用子类的构造方法 可调用其他方法为父类的方法、子类重写的方法

向下转型运算符
1> as： 强制将运算符前面的引用变量转换为后面的类型
2> as? 可选形式的向下转换

（向下转换只能在具有继承关系的两个类型之间进行）</strong>

计算属性

class User{
    var first: String = ""
    var last: String = ""
    
    //定义计算属性
    var fullName: String{
        //定义计算属性的getter方法，该方法的返回值由first、last两个存储属性决定
        get{
            return first +”-“+ last
        }
    //定义计算属性的setter方法，该setter方法将负责改变该实例的first、last两个存储属性
        set(newValue){
            var names = newValue.componentsSeparatedByString("-“)
            self.first = names[0]
            self.last = names[1]
        }
    }
    init(first: String , last: String){
        self.first = first
        self.last = last
    }
}

let s = User(first:"geek",last:"hello")
print(s.fullName) //调用get方法
s.fullName = “geek-aa” //调用set方法

属性观察者

//willSet(newValue) 被观察的属性即将被复制之前自动调用的方法
//didSet(oldValue) 被观察的属性被复制完成之后自动调用的方法
class Person{
    //存储属性
    var name: String = "" {
        willSet{
            if(countElements(newValue)>6) || (countElements(newValue)<2)
            {
                print(\(newValue))
            }
            else{
                print(“人名不符合要求，设置成功")
            }
        }
        didSet{
            print(“人名设置符合要求，设置成功")
        }
    }
}
var p =Person()
p.name=“aaa"

下标

struct JK{
    var x: Int
    subscript(index: Int) -> Int{
        get{
            switch(index){
                case 0:
                    return self.x
            }
        }
        set{
            switch(index){
                case 0:
                    self.x = newValue
            }
        }
    }
}

var rect = JK(x:20)
rect[0]=20

可选链

1.使用可选链访问方式：将强制解析的感叹号换成？，在隐式解析的后面也添加？后缀

2.可选链会自动判断程序访问的关联实例是否为nil

类型属性

static 定义枚举的类型存储属性、计算属性、类型方法，使用可选类型，系统将其初始化为nil
static var desc : String?
static var maxArea: Int{
    get{} set{}
}
static func ser(){}
class 定义类的类型计算属性、类型方法
class var desc : String{
    set{} get{}
}
class func abs(){}

嵌套类型

//在类型内部嵌套类型
class User{
     var holidays:[Weekday]
     var location:Point
     init(holidays:[Weekday],location:Point){
         self.holidays = holidays
         self.location = location 
     }
     struct Point{
         var latitude: Double
         var longitude: Double 
         var position: Orirntation
         enum Orientation{
              case Up,Left,Bottom,Right 
         }
     }
     enum Weekday{
          case Monday,Tuesday
     }
}

拓展

[修饰符]extension 已有类型{
     //添加新功能
}
修饰符可以省略，或者是private、internal、public其中之一，类型可以是枚举、结构体和类其中之一

extension String{
     static var data:[String:Any] = [:]
     
     var length: Int{
          get{}
          set{}
     }
     
     func substringFromStart(start: Int,toEnd: Int) -> String{
          ……
     }
     
     static func valueOf(value:Bool) -> String {
         return "\(value)" 
     }
}
String.data["swift"] = 89
var str = "a"
str.length = 5
var subStr = str.substringFromStart(5,toEnd:10)
String.value(true)

//拓展可以增加构造器  
//枚举拓展

协议（类似接口）

语法格式：
[修饰符] protocol 协议名:父协议1，父协议2，...{
     //协议内容
}
修饰符：可以省略，也可以是private/internal/public之一
协议只能继承协议 不能继承类

Struct结构体名:第一个协议,第二个协议,...{
     //实现协议要求
}

Class 类名:SuperClass(父类),第一个协议,第二个协议,...{

}