Swift入門篇-基本類型

Swift入門篇-基本類型

一：元組

格式   

變量或常量關鍵字  元組變量 ＝ （ 變量，變量, …）

說明： 

1: 元組變量仍是一個變量，只不過表現方式和其餘變量不同

2：()括號裏面能夠放入N個變量組成

例子；

import Foundation


/*
A是元組變量，（)裏面放着 整形 和字符串


元組類型爲 整形和字符串 組成
*/


var  A = (1,"swift」)//元組變量A 由 整形和字符串 組成
println(A)

運行結果

(1, swift)

mport Foundation


var B = 12  
/*
定義一個元組，元組變量爲C , （）裏面放 整形變量B 和字符串。


元組類型有 整形 和 字符串組成
*/


var C = (B,"Swift") //元組變量B  由 整形和字符串組成
println(C)

運行結果

(12, Swift)

 

元祖訪問方式

1：匿名元組變量來訪問

說明：

 1.1 匿名元組變量和定義好的元組變量參數必須一致

 1.2 須要元組中的個別值，能夠使用(_)來忽略不須要的值

例子（1.1）

import Foundation




var A = (1,"Swift") //元組變量A  由 整形和字符串組成


/*


1: A 是元組變量，由整形和字符串組成
2：(B,C)是一個匿名元組變量
3：元組變量A 所對應的值，一一對應賦值給匿名變量。即B =1  C = "Swift"


注意點：
定義的匿名元組變量個數必須和定義好的元組變量值的個數相同


*/


var (B,C) = A
println("B=\(B),C=\(C)")

運行結果

B=1,C=Swift

例子 （1.2）

import Foundation

var A = (1,"Swift") //元組變量A  由 整形和字符串組成


/*


1: A 是元組變量，由整形和字符串組成
2：(_,C)是一個匿名元組變量,其中x下劃線(_)表明省略變量
3：元組變量A 所對應的值，一一對應賦值給匿名變量。即 B="Swfit"


注意點：
定義的匿名元組變量個數必須和定義好的元組變量值的個數相同


*/


var (_,B) = A
println("B=\(B)")

運行結果：

B=Swift

 

2：經過索引來訪問 （與數組訪問類似）

import Foundation

var A = (1,"Swift") //元組變量A  由 整形和字符串組成


println(A.0)// A.0 指的是訪問 元組變量中的第一個元素 即 1
println(A.1)// A.1 指的是訪問 元祖變量中的第二個元素  即 」Swift"

運行結果

1 Swift

 

3：經過key來訪問

注意點：

 前提是  

1： 元組變量中變量必須由於字典來訪問

2：訪問方式即： 元組變量.key

import Foundation


/*
 經過key 來訪問元組變量 注意點
1：對應的變量，必須爲字典  key: value
2: 訪問的時候，元組變量.key
*/


var  A = (frist:"Hello",second:"swift")


println( A.frist )
println( A.second )

運行結果

Hello swift

 

二：類型轉換

 1：字符串轉換爲整形 (toInt())

import Foundation

//字符串轉換爲Int 類型

var  strA =  "123"
var  value =  strA.toInt() // toInt 函數是把字符串 轉換爲整形

println("value=\(value)")

var strB = "12A"
var value1 = strB.toInt() //toInt 函數是把字符串 轉換爲整形 其中轉換失敗值爲nil

println("value1=\(value1)")

運行結果

value=123 value1=nil

 

 

var B = A.toInt() 這個函數 字符串轉換爲整形 看一下圖

其中 B 爲 Int? （可選值） 能夠包含整形值和nil 

var A:Int = 10 

var A:Int? = 10  

不一樣點： var A:Int? = 10 不只能夠包含整形值，還能夠包含nil var A:Int = 10 只能包含整形值 

2：浮點類型轉換整形 (Int())

import Foundation


var  A = 1.10


 var B = Int(A) //把浮點類型強制轉換爲整形


println("B=\(B)")

運行結果

B=1

3：整形轉換爲浮點類型 （Double())

import Foundation


var  A = 1


 var B = Double(A) //整形轉換爲浮點類型
var C = Float(A)


println("B=\(B) C=\(C)")

運行結果

B=1.0 C=1.0

 

條件語句用法 （if )

 第一種方法


if 布爾值  ｛｝  


 注意點 


1： 布爾值等於true 就執行if 裏面的方法
2：｛｝ 不能省略  不然會報錯


第二種方法


if  可選值   {｝


注意點：


1： 可選值不等於nil  就執行if 裏面的方法
2:   {} 不能省略  不然會報錯




第三種方法


if let  常量值  ＝ 可選值 ｛｝


注意點：


1：if let  常量值  ＝ 可選值  是把 可選值 賦給 常量值，若是常量值不爲nil　就執行if　裏面的方法
2：  {} 不能省略  不然會報錯

例子

第一種方法（if +布爾值）

import Foundation

var A = true

// if 後面 跟bool值 爲true的時候執行 if後面的｛｝的方法
if A {
    println("A=\(A)")
}
else{
    println("A")
}

運行結果

A=true

第二種方法  （if +可選值）

import Foundation

// -----------------------------可選值不爲nil ----------------
var  A:Int? = 10


//A 的類型int?（可選類型）, 若是A不爲nil 就執行 if 中｛｝ 裏面的方法
if A {
    println("A=\(A)")
}
else{
    println("A=nil")
}


//---------------------------可選擇爲nil---------------


var B:Int? //B 爲可選類型，不賦值 默認爲nil  若是B 爲nil就不執行　if中｛｝ 的放法


if B {
    println("B=\(B)")
}
else {
     println("B=nil")
}

運行結果

A=10 B=nil

第三中方法 （if  let 常量名 ＝ 可選值）

import Foundation

//--------------- if let  可選值不爲nil
var  A:Int? = 10


if let B = A{ //解釋 A 的值賦給 B 若是B 不爲nil  執行 if　｛｝　中方法
    
    println("B=\(B)")
}
else{
     println("B=nil")
}




//--------------- if let  可選值爲nil


var  C :Int? //C 是可選值 ，不賦值 默認爲nil


if let D = C { //解釋 C 的值賦給 D 若是D 爲nil  不執行 if　｛｝　中方法
        println("D=\(D)")
}
else{
    println("D=nil")
}

運行結果

B=10 D=nil