皮卡丘愿你開(kāi)心.jpg

常量和變量

在Swift中使用 let 修飾一個(gè)常量, 使用 var 修飾一個(gè)變量;

• let 修飾常量的值是不可以更改的
• var修飾的變量的值是可以更改的;
• 在聲明常量和變量的時(shí)候可以用表情符號(hào), 中文等命名常量名和變量名.

//輸出函數(shù)
print("Hello, World!")

// 定義一個(gè)常量

// 方法 1:
//定義之后,后面的值只能是字符串,因?yàn)橹付顺Ａ康念?lèi)型
let name:String = "詹姆斯"
// 方法 2:
//特性: 隱式類(lèi)型推斷,由初始值來(lái)推斷常量的類(lèi)型
let gener = "男"

• 使用let定義的常量的值永遠(yuǎn)不可以更改

//定義一個(gè)變量的方式

// 方式 1:
var age = 100
// 方式 2:

var height : Int = 140` 
- Swift 在定義一個(gè)變量或者常量的時(shí)候,必須要有確定的類(lèi)型
`leta :Int= 10
let b : String = "James"
let c : Character = "A" //字符使用雙引號(hào),但是只能放單個(gè)字符
let d : Bool = false  // false 和 ture```

字符串String

有序的字符的集合 
####//創(chuàng)建一個(gè)字符串類(lèi)型的常量
`let string = "詹姆斯"`

####//創(chuàng)建一個(gè)值為空的字符串
`let string1 = ""
let string2 = String();`

####//字符串拼接
`var name = "韋德"
var newName : String = name + “520"`

####//獲取字符串的長(zhǎng)度
`print(newName.characters.count)
`
####// 運(yùn)算符重載 當(dāng)對(duì)兩個(gè)字符串類(lèi)型做加法操作時(shí), 會(huì)自動(dòng)拼接到一起

```code
let q = "保羅"
let w = "安東尼"
let r = q + w```

####//Swift 不支持隱式類(lèi)型轉(zhuǎn)化

```code
var age = 100
let e = "Cobain's age is"
let words = e + String(age)```

####//如果想要對(duì)兩個(gè)不一樣的數(shù)據(jù)類(lèi)型的變量或者常量進(jìn)行運(yùn)算,需要使用這樣的格式:
```code
// 變量(常量) A +\-\*\/ 目標(biāo)類(lèi)型(B)
var width = 100.2
var f = width + Double(height)```

###數(shù)組
> ####//定義空數(shù)組
`var array3 = [String]()`
####//向數(shù)組中追加一個(gè)元素
`array1.append(108)`
####//使用運(yùn)算符重載 向數(shù)組中追加一個(gè)或多個(gè)元素
`array1 += [502]`
####//在數(shù)組指定位置插入一個(gè)元素
`array1.insert("科比", atIndex: 2)`
####//向數(shù)組指定位置插入 一個(gè)相同類(lèi)型的集合數(shù)據(jù)
`let array5 = ["麥迪", 52]
array1.insertContentsOf(array5, at: 2)`
####//全部刪除
`array1.removeAll()`
####//全部刪除 但保留內(nèi)存
array1.removeAll(keepCapacity: true)
####//刪除第一個(gè)元素
`array1.removeFirst()`
####//從第一個(gè)元素開(kāi)始刪除幾個(gè)
`array1.removeFirst(2)`
####//刪除指定位置的元素
`array1.removeAtIndex(2)`
####//刪除最后一個(gè)元素
`array1.removeLast()`
####//刪除range范圍的元素(包含起始索引,不包含終止索引)
```code
let range : Range = Range.init(start: 1, end: 4)
array1.removeRange(range)
print("kiki\(array)")```

###字典

>//定義一個(gè)字典
```code
var dict = Dictionary<String, Int>()
let dictionary = ["a" : 1, "b" : 2]```
//當(dāng)key的類(lèi)型不一樣時(shí), key就為 NSObject類(lèi)型
```code
let dictionary1 = ["a" : 1, 2 : "b"]```
//提前指定key和value的類(lèi)型 創(chuàng)建一個(gè)字典
```code
let dictionary2 : [Int : String] = [1 : "a", 2 : "b"]```
//可以直接通過(guò)key值訪(fǎng)問(wèn)字典中的元素print(dictionary2[1])
```code
var dictionary3 = ["詹姆斯" : "韋德", 102 : 522]
dictionary3["韋德"] = "歐文"```
//對(duì)一個(gè)不存在的key值進(jìn)行操作, 即 插入一條數(shù)據(jù)
```code
dictionary3["樂(lè)福"] = "love"```
// 讓某一個(gè)key值為nil 表示刪除掉這個(gè)key和對(duì)應(yīng)的value
```code
dictionary3[102] = nil
dictionary3.removeValueForKey("詹姆斯")```

###元組

>- //元組是一個(gè)可以返回多個(gè)值的數(shù)據(jù)格式
- //在Swift里面聲明的時(shí)候使用"()"聲明
- //元組可以通過(guò)下標(biāo)去訪(fǎng)問(wèn)元素, 也可以通過(guò)key值去訪(fǎng)問(wèn)元素
- //整體的數(shù)據(jù)結(jié)構(gòu)有點(diǎn)類(lèi)似C語(yǔ)言里面的結(jié)構(gòu)體


>```code
let type = ("東邪", ["西毒", "南帝"], "北丐", "伯通")
print(type)
print(type.0)```
//定義數(shù)據(jù)類(lèi)型
```code
let type1 : (String, Int) = ("喬峰", 100)```
//根據(jù)key值輸出
```code
let type2 : (name : String, age : Int) = type1
print(type2.age)```

--------------
###循環(huán)和分支:
---------------
- **// for循環(huán)**
```code
forvar i = 0; i < 100; i++ {
    print(i)}for (var i = 0; i < 100; i++){    print(i)
}```

- **// for in 循環(huán)遍歷**
// 1...10 表示全閉區(qū)間 [1,10]
// 1..<10 表示半閉區(qū)間 [1,10)
for i in 1...10 {    print(i)
}

```code
let animals = ["豬", "狗", "貓", "雞"]
for a in animals{    print(a)}
let dict = ["東邪" : "黃藥師", "西毒" : "歐陽(yáng)鋒"]
for b in dict {    print(b)}
for (key, value) in dict
 {    print("key : \(key) value : \(value)")
}```
- //while
```code
var number = 0
while number < 10 {    
print(number)   
 number += 1
}```

- // repeat while 即C中的 do...while
```code
var num = 0
repeat {   
 print(num)    num += 1
} 
while num < 10```
--------------
## //分支結(jié)構(gòu):
----------------
```code
  if 1==0 {   }```

- // String? 在變量的類(lèi)型后面加 ? , 表示這個(gè)變量為可選類(lèi)型, 可以置為nil
```code
 var string : String? = "James"
if (string != nil) {   }```

- //在Swift里面, 每一個(gè)case里面自帶一個(gè) break
```code
let age = 23
switch age {
case 1:
    print("age = 1")
    fallthrough  //貫穿 (不會(huì)break,而回繼續(xù)走case 2)
case 2:    
print("age = 2")
case 3:   
 print("age = 3")
case 4:   
 print("age = 4")
default :    
print("age = 5")}```
- //Swift中的switch可以根據(jù)區(qū)間去獲取值

```code
switch age {case 0...10:   
 print("一毛")
case 11...20:    
print("二毛")
case 21...30:   
 print("三毛")
default:    print("四毛")}
var a = 5
switch a
 {
case var value where a < 10 && a > 0:    
          value += 1   
          print(value)
default:    print("Other")}```

- // Swift中的switch可以對(duì)一個(gè)元組做判斷
- // "_"表示忽略元組中這個(gè)位置的元素
- // 條件齊全了,就可以不寫(xiě)default
```code
let point = (10, 42)
switch point 
{
case (10, 10):    print("第一象限")
case (_, 10):    print("一,二 象限")
case (10, _):    print("一, 四象限")
case (_, _):    print("誰(shuí)知道在哪")
}```

-------------
###函數(shù)
------------
>無(wú)參無(wú)返回值
無(wú)參有返回值
有參無(wú)返回值
有參有返回值
無(wú)參有多個(gè)返回值
有參有多個(gè)返回值
inout函數(shù)

- //func + 函數(shù)名 (參數(shù)列表) -> 返回值類(lèi)型(無(wú)返回值可以以省略 -> Void) {}
```code
func text() -> Void {    print("無(wú)參無(wú)返回值的函數(shù)")
}
text()

• //無(wú)參有返回值

func text1() -> String 
{   
 return "無(wú)參有返回值"
}
let string = text1()
print(string)```

- //有參無(wú)返回值
```code
func text2(name : String, age : Int)
 {    
print("東邪是\(name), \(age)")
}
text2("黃藥師", age : 100) ```
 // age : 外部參數(shù)名

- //有參有返回值
```code
func text3(name : String, age : Int) -> Array<NSObject> 
{    
let array : Array<NSObject> = [name, age]   
return array
}
let array : [NSObject] = text3("孫悟空", age : 599)
print(array)```

- #####//函數(shù)的外部參數(shù)名第一個(gè)名字表示外部參數(shù)名, 當(dāng)外界使用這個(gè)函數(shù)的時(shí)候使用的名字. 第二個(gè)參數(shù)表示內(nèi)部參數(shù)名, 當(dāng)函數(shù)里面使用這個(gè)參數(shù)的時(shí)候使用的名字, 外部函數(shù)可以用 _ 忽略掉
```code
func text4(number myNumber : Int, name myName : String) 
{    print("名字是\(myName), 編號(hào)是\(myNumber)")
}
text4(number: 101, name: "二狗蛋")```
- //無(wú)參數(shù)有多個(gè)返回值的
```code
func text5() -> (String, Int)
 {    return ("張三", 108)
}
let type = text5()
print(type)```

- //有參有多個(gè)返回值
```code
func text6(name myName : NSString,age myAge : Int) -> (NSString, Int)
{    return (myName, myAge)
}
let type2 = text6(name: "萌萌", age: 102)
print(type2)```

- //函數(shù)嵌套

func text7()
 {   
> func text()
 {        
print("第一層嵌套函數(shù)")       
>> func text2() 
{            
print("第二層")            
>>>func text3()
 {
 print("第三層")  
 }  
  >>>> text3() 
 }      
text2()    
}    
text()
}

text7();

- //inout 函數(shù)
- // Swift 中的參數(shù) 本身上是使用let定義的,即常量, 是不能更改的
- // 如果參數(shù) 使用 inout 來(lái)修飾, 就成了輸入輸出參數(shù),在函數(shù)內(nèi)部修改參數(shù),可以影響實(shí)參變量的值.
```code
func text8(inout name : String) 
{
    name = "艾弗森"
}
var name = "AI"
text8(&name)
print(name)```

--------
可選類(lèi)型:
-------
-------
//在swift中, 可選類(lèi)型 ? 其根源是一個(gè)枚舉型, 里面有None和Some兩種類(lèi)型.其實(shí)所謂的nil就是Optional.None, 非nil就是 Optional.Some
//定義一個(gè)可選類(lèi)型, 表示這個(gè)變量可以為nil
`var intNumber : Int? = 100`
//打印  打印出來(lái)是個(gè)Optional類(lèi)型的值
`print(intNumber)`
//如果 要取到值 必須對(duì)可選類(lèi)型 強(qiáng)制解包 !
print(intNumber!)
//可選類(lèi)型分為有值和沒(méi)值(nil) ,如果可選類(lèi)型的變量值為nil(沒(méi)值)時(shí)對(duì)其 強(qiáng)制解包,程序會(huì)崩潰

//如果不確定可選類(lèi)型是否有值時(shí),用可選綁定, 不需要對(duì)可選類(lèi)型解包
```code
if var intNewNumber = intNumber 
{    
print(intNewNumber)
}else{    
print("error")
}```

--------
結(jié)構(gòu)體
-------
-------

/\* Swift的結(jié)構(gòu)體對(duì)比OC來(lái)說(shuō), 可以添加初始化方法, 可以遵守代理協(xié)議等 */
###//使用struct定義一個(gè)結(jié)構(gòu)體
###//格式 : struct 結(jié)構(gòu)體名字 { 結(jié)構(gòu)體實(shí)現(xiàn) }

```code
struct Frame {    
//存儲(chǔ)屬性 : 負(fù)責(zé)存儲(chǔ)值的屬性    
var x : Float    
var y : Float    
var width : Float    
var height : Float }```     
######//計(jì)算屬性 : 負(fù)責(zé)將存儲(chǔ)屬性進(jìn)行運(yùn)算獲得的值的屬性    
######//get方法 : 在屬性類(lèi)型后面添加 {} 使用get關(guān)鍵字聲明和實(shí)現(xiàn)get方法    //set方法 : 同上   
```code
 var centerX : Float
 {       
 set{           
       // set方法 不可以單獨(dú)實(shí)現(xiàn), 必須搭配著get方法        
      }        
 
 get{           
    //get方法 可以單獨(dú)實(shí)現(xiàn)        
         return x + width/2        
     }    
 }      
 var centerY : Float
 {       
 get{            
      return y + height/2       
      }    
 }   ```
// 結(jié)構(gòu)體屬性    
`static var myStruct = "結(jié)構(gòu)體屬性, 只能通過(guò)結(jié)構(gòu)體調(diào)用"    `   
//結(jié)構(gòu)體中可以聲明和實(shí)現(xiàn)函數(shù)    

```code
// 結(jié)構(gòu)體屬性
func sayHi() 
{       
    print("函數(shù)")
 }   ```    
####//init方法   
```code
// 結(jié)構(gòu)體屬性
init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float) {      
  x = newX        
  y = newY        
  width = newWidth        
  height = newWidth    } ```
  //結(jié)構(gòu)體的類(lèi)方法  
  // 結(jié)構(gòu)體的類(lèi)方法中只能調(diào)用結(jié)構(gòu)體屬性  
```code
  static func sayMy() 
{        
    print(self.myStruct)    
}   ```
//屬性作用 :
//聲明 _實(shí)例變量
//聲明和實(shí)現(xiàn)set方法
//聲明和實(shí)現(xiàn)get方法
//結(jié)構(gòu)體調(diào)用 (調(diào)用兩個(gè)屬性 )

    Frame.sayMy()
    print(Frame.myStruct)
//創(chuàng)建一個(gè)對(duì)象的方式
//方式 1:
```code
var frame1 : Frame = Frame.init(x: 10, y: 10, width: 100, height: 100)```
//方式 2: 自帶的構(gòu)造方法
```code
var frame2 : Frame = Frame(x: 10, y: 10, width: 100, height: 100)```
//對(duì)象調(diào)用屬性
`print(frame1.centerX)`
//對(duì)象調(diào)用方法
`frame1.sayHi()`