Swift學習筆記

在swift中=先後必定要用空格隔開,否則會報錯的 常量和變量的使用,

//常量以 let 修飾
	常量指向的內存地址是不能夠修改的,可是能夠修改內部的屬性
	let a : int =20
	let修飾 , a不能夠在從新的進行賦值
	let a : UIView = UIView();  
	例如指向的是一個對象,能夠修改對象內部的屬性 例如:
	a.alpath = 0.5;//能夠設置內部的屬性
	
//變量以 var 修飾
	var a : int =20

對象

//建立對象 OC 中的寫法
UIView view = [[UIView alloc]init];
//建立對象 swift中的寫法
let view : UIView = UIView();  //

類型推導 意思是能夠根據賦值,系統會自動推導出前面的類型,類型能夠省略不寫,舉例

let a : Int = 20
let a = 20

let view : UIView = UIView()
let view = UIView();

基本運算 在swift中不一樣類型是不能夠進行計算的,例如一個double類型與int類型進行運算,惟一的辦法能夠進行轉換,例如

let a : Int = 20
let b : Double = 12.2
let c = a + Int(b)  //必須進行轉換,才能計算
//通常若是一個變量+1的話,咱們常常這樣寫a++,但在swift中正確的寫法是a+=1
a+=1 //表示a+1=a

邏輯分支 判斷語句中沒有YES 和 NO ,都以true 和 false 替換掉了

let a : Int = 10
if a>80 {           //能夠省略()
   print("進來了")
}

//guard 的使用,guard是Swift2.0新增的語法 相似於if
//oc寫法
func onlinre (age : Int){
    if(age > 8){
        print("大於8")
    }else{
        return
    }
    
}


//swift寫法
func onlinr (age : Int){
    guard age > 8 else {
        return
    }
    
    print("大於8")
    
}
onlinre(age: a)
onlinr(age: a)

switch語句中break能夠省略 switch後面的()也能夠省略

let a = 2
switch a {
case 2,3:
   print("hahah ")
    fallthrough //這個值表示能夠直接跟着下面那個條件一塊兒成立 ,也就是說若是2,3知足 ,也會直接進行走下面的語句
case 12:
    print("hahah ")
default:
    print("nihao ");
}

關於區間 swift中的區間分爲 半開半閉區間和閉區間<br> //描述0-9的全部數據<br> 1.半開半閉區間 0..<10<br> 2.閉區間 0...9<br>

關於for循環

//表示打印0-10的全部數字,注意是三個點
for i in 0...10 {
    print(i)
}

//表示打印0-9的全部數字,注意是兩個點,後面再加上運算符
for i in 0..<10{
    print(i)
}

//若是i沒有被使用的話,能夠在前面加上_,優勢不佔用內存空間
for _i in 0..<10{
    print("hah")
}

字符串 在oc中使用NString swift中使用String String是一個結構體,性能比OC好

let str : String = "哈哈哈"
let str2 : String = "哈哈哈"
print("我打印了\(str2)")//相似於oc中 NsLog("我打印了%@",str2)


let a = 4;
let b = 5;
let ss = String(format: "%02d:%02d", a,b)//轉化爲 04:05
print(ss)

//(name as NSString)  as表示將String 轉化爲 NSString
let name : String = "我是唐林淵"
(name as NSString).substring(to: 2)

數組的幾種寫法

var array = ["a","b","c"]
var array1 : Array<String> = ["a","b","c"];
var array2 = [String]()

 array.append("哈哈")//添加
 array[0] = "aa"//修改
    print(array.count)
 //array.removeAll()//刪除

//遍歷的兩種方法


//第一種只能發到對應的值
for i in array {
    print(i)
}

//第二種  既能夠拿到index 也能夠拿到對應的item
for (index1,item1) in array.enumerated(){
    print( String(format: "當前的下標爲\(index1)當前的內容爲\(item1)", index1,item1))
}

定義字典

//第一種寫法
var dict : Dictionary<String,Any> = ["name":"jack"];//注意若是values不肯定類型的話,直接用Any表示
//第二種寫法
var dict1 : [String:Any] = ["name":"jack"];

//建立一個可變字典
var dict2 = [String:Any]()
//添加
dict2["name"] = "jack"
dict2["age"] = "18"
dict2["height"] = "188"
//修改
dict2["name"] = "tom"
//刪除
dict2.removeValue(forKey: "name")

for item in dict2.keys {
    print(item)
}


for (key,value) in dict2 {
    let st = String(format: "這裏的key=\(key),這裏的value=\(value)", key,value as! String)//注意:因爲寫的是Any,表示任意類型,因此這一步須要轉換,
    //as! String    表示轉化爲String 類型
    print(st)
}

關於元組 元組相似於OC中的數組,字典

//第一種寫法  能夠經過位置角標直接取值
let y = ("name","man","188");
y.0
y.1
y.2

//第二種寫法  能夠經過對應的key 直接取出相對應的值,通常使用這種
let x = (name: "name",age:"18")
x.age
x.name

//第三種寫法
let (name,age) = ("name","18");

關於可選類型<br> 在OC開發中,若是一個變量暫時不適用,能夠直接賦值爲0,或者賦值爲空<br> 在Swift開發中nil也是一個特殊的類型,不能將一個暫時不使用的變量賦值爲nil ,能夠利用Optional或者?來代替

//var s : String = nil //錯誤寫法
//第一種可選類型的寫法

var s : Optional<String> = nil //初始化爲nil
s = Optional("name") //賦值
print(s!)//取值的時候,後面加上!,爲了解析內容

//第二種寫法
var y : String? = nil
y = "jack"
print(y!)


//須要注意的是加上!來解析,假若指仍是nil的話,解析會報錯
if(y != nil){//多加一層判斷
    print(y!)
}

if let y = y {//利用可選綁定(推薦使用)
    print(y)
}

let s : String = "123"
let a : Int? = Int(s)// 表示裏面轉換有可能爲nil,因此類型是個可選類型
print(a!)//打印結果是Optional(123)


let url = URL(string: "www.baidu.com")//也是可選類型,能夠長按option+鼠標左鍵點擊url,能夠查看類型
if let url = url {
    print(url.absoluteString)
}


let dict : [String:Any] = ["name":"jack","age":18]
let name = dict["name"]//長按option+鼠標左鍵點擊url,能夠查看類型爲Any? 也就是說有可能中間name沒有在整個字典中

//結論 只要一個類型有可能爲nil,那麼這個標識符的類型必定是一個可選類型

關於類型轉換 as as? as! ??

let s = "123"
(s as NSString).length //as 表示將s轉化爲NSString類型

let dict : [String:Any] = ["name": "jack","age" : 18]
//as?表示轉化可選類型
let name = dict["name"] as? String //第一種寫法

if let name = dict["name"] as? String {//第二種寫法
    print(name)
}

//as! 表示轉化爲具體的類型,若是轉化不成功,系統將會直接崩潰,通常狀況不使用
let name1 = dict["name"] as! String
print(name1)

//?? 下面的語句表示若是a有值,就賦值給i,若是沒有值就拿?? 後面的值賦值給i

var i = Int(a) ?? 0

函數使用

//1.沒有參數,沒有返回值
func test(){
    print("nihao ")
}

test()


//2.有參數 沒有返回值
func test1(name:String){
    print(name)
}

test1(name: "jack")

//3.沒有參數,有返回值
func test2() -> String{
    print("沒有參數,有返回值")
    return "哈哈"
}

print(test2())

//4,有參數,有返回值
func test3(name:String) -> String{
    return name
}

print(test3(name: "jakctang"))

func test(name : String,age:Int){
    print(name)
}

關於函數參數的使用

//調用
test(name: "jack", age: 12)
//若是想修改外部name的名字,直接在前面加上名字便可
func test1(name1 name : String,age:Int){
    print(name)
}
test1(name1: "jack", age: 12);//調用名稱就變爲name1

//若是要隱藏名稱,直接在name前面加上下劃線,能夠直接將name名稱隱藏掉
func test2(_ name : String, age : Int){
  print(name)
}

test2("jack", age: 12)

//可變參數,好比若是要打印0-100因此的數字,後面加三個點
func test3(number : Int ...){
    print(number)
}
test3(number: 1,2,3,4,5,6)

函數傳入參數能夠自動寫入默認

//在類型後面加上=值,表示調用此方法若是不傳值,就是用=後面的值
func test(name:String = "jack"){
    print(name)
}
test(name: "tang")
test()

//指針參數  在類型前面加上inout 便可
var m = 20
var n = 10

func test2(num1 : inout Int ,num2 : inout Int){
        let temp = num1
        num1 = num2
        num2 = temp
}

test2(num1: &m, num2: &n)

print("m:\(m) n:\(n)")

枚舉類型

//記着添加類型,否則是沒法賦值的
enum EnumType : String{
    case NumBerType = "number"
     case IntType = "int"
}

//第二種定義方法
enum EnumType1 : String{
    case NumBerType,IntType
}

關於結構體,前面用struct來修飾

struct  JackDemo{
    var name : String = "jack"
    
    mutating func changgeName(n:String) {//若是要修改裏面的成員屬性,必須在前面添加mutating
        name = n;
    }
    
}

var jack : JackDemo = JackDemo(name: "name")//結構體會自動建立幾個關於變量的函數,若是要從新構造函數
var jac : JackDemo = JackDemo()

print(jack.name)
print(jac.name)

類的基本使用

class Demo : NSObject{
    //若是屬性是值類型,則初始化爲空值
    //若是屬性是對象類型,則初始化爲nil值
    var name : String = ""
    var age : Int = 0 {  // willSet和didSet 監聽屬性改變
        willSet{
           
        }
        
        didSet{
        }
    }
    static var view : UIView? //經過類名進行訪問
    
    override init(){//系統會默認建立此構造方法,若是自定構造函數,會覆蓋次方法,除非重寫
        
    }
}

var demo : Demo = Demo()



//調用setValuesForKeys 前提是必須繼承NSObject  重寫super.init()  爲了防止有多餘的key或者報錯從新 forUndefinedKey
class Person : NSObject{

    var name : String = ""
    var  age : Int = 0
    
    init(dict : [String : Any]) {//字典
//        if let name = dict["name"] as? String{
//            self.name = name;
//        }
        super.init()//必須重洗super.init()
        setValuesForKeys(dict) //使用字典
    }
    
    override func setValue(_ value: Any?, forUndefinedKey key: String) {}//重寫forUndefinedKey
    
    
    
    deinit {//監聽對象的銷燬
        
    }
}


//可選列
class Person{
    var b :Book?
}
class Book{
    var n : Name?
}
class Name{
    var s : String = "名字"
}

let p = Person()
let b = Book()
let n = Name()
 n.s = "hah"
p.b = b
b.n = n

if let name = p.b?.n?.s {//取值操做
    print(name)
}

protocol 來修飾一個協議,協議名稱後註明給class來遵照,默認狀況下,必須實現

@objc protocol onclick : class{
  @objc optional func test()
   func test1()
}

class Person : onclick{//遵照協議,默認狀況,必選所有實現方法,若是想要可選實現的話,必須在類名和方法名字前面加上 @objc optional
    
    func test() {
        
    }
    
    func test1() {
        
        
    }
    
}


class Person {
    weak var deletse : onclick? //可讓繼承者遵照,屬性最好用weak,防止循環
    
    func test() {
        deletse?.test()
    }
    
    func test1() {
        
        
    }
}

懶加載(關於懶加載的兩種寫法)

lazy var names : [String] = ["jack","tom"]
    
    lazy var nbookName : [String] = { (推薦使用)
        let nbname = ["ehy" ,"assa"]
        return nbname
    }()
    
    
    //懶加載一個控件,而且設置屬性
    lazy var btn : UIButton = {
        let  btn = UIButton()
         btn.setTitle("按鈕", for: .normal)
        return btn
    }()

Swift的權限訪問<br> internal : 內部 (默認狀況全部都是internal,在本項目中就能夠訪問)<br> private : 私有的 只有在本類中訪問<br> open : 公開的 能夠在別的項目中也能夠訪問(就是說在別的包中也能夠訪問,例如UIButton是一個控件,在別的包中)<br> fileprivate : 同一個文件中