Swift入门-Day 1

一.swift语言基本类型

• 整形 Int
• 浮点类型 Float Double
• 字符类型 String
• 集合类型 Array Dictionary
  注意点：
  1： 基本类型 首写字母 要大写。
  2： 基本类型不能直接定义 类型变量 （这和其他语言有所不同）
  例如：Int A=10 //错误，基本类型不能直接定义变量

二.变量

定义变量的关键字是 var
var 变量名 = 变量值 //编译器通过变量值推断变量类型
例如：
var a = 10
var b = “swift”
var c = true

三.常量

定义常量的关键字是 let；
let 变量名 = 变量值
例如：
let a = 10
let b = false

常量和变量的区别：

1：常量只能赋值一次，不能在修改

2：变量可以修改多次，修改过的变量值的类型必须相同。

四.定义指定类型的变量

var 变量:类型 = 变量值
//直接定义变量的类型（而不是通过变量值来推断变量类型）

例如：
// main.swift
// 基本类型2
import Foundation

var A:Int = 10 //直接定义 变量A 的类型为整形
println(“A=(A)”)

var B:Bool = true//直接定义 变量B 的类型为布尔类型
println(“B=(B)”)

var C:String = “SWIFT” //直接定义 变量C 的类型为字符串类型
println(“C=(C)”)

五.定义指定类型的常量

let 常量 : 类型 ＝ 常量值
//直接定义常量的类型（而不是通过常量值 来推断 常量类型）

注意点：

var A = 10 和var A:Int = 10 的区别？

var A =10 //编译器直接通过 变量值 10 来推断 变量A 的类型是整形

var A:Int = 10 //直接指定 A 的类型是整形

六.数据类型
1.进制表现方式
格式：
十进制数，无前缀

二进制数，以 0b 为前缀

八进制数，以 0o 为前缀

十六进制数，以 0x 为前缀
注意：
定义的变量或常量 存储值为十进制。
例如：
//
// main.swift
// 基本类型2
import Foundation
var D = 0xA
/*
1：变量值0xA 前缀是0x 十六进制
2: 变量或常量储存的值必须为十进制
3: 十六进制A 转换为十进制之后，在赋值给变量C
*/
println(“D=(D)”)

运行结果
D=10

2.整形变现形式
整形 ：有符号和无符号类型

有符号类型：Int ,Int8 ,Int32,Int64

无符号类型: UInt ,UInt8 UInt32,UInt64

注意点：
　　如果你的开发环境是32位，那么Int = Int32
　　如果你的开发环境是64位，那么Int = Int64

例：
import Foundation

var UInt8Min = UInt8.min //UInt8.min 是求UInt8的最小值
var UInt8Max = UInt8.max //UInt8.max 是求UInt8的最大值

println(“UInt8Min=(UInt8Min),UInt8Max=(UInt8Max)”)

var Int8Min = Int8.min //UInt8.min 是求UInt8的最小值
var Int8Max = Int8.max //UInt8.max 是求UInt8的最大值

println(“Int8Min=(Int8Min),Int8Max=(Int8Max)”)

运行结果

UInt8Min=0,UInt8Max=255
Int8Min=-128,Int8Max=127

3.数字可读性

例如：下划线（整形用法）
//
// main.swift
// 基本类型2
import Foundation

var A = 110000
var B = 110_000//下划线可以放置任何位置
var C = 1_100_00
/*
1： A ,B,C 输出结果是相同的
2：用下划线(_)用来分隔 外数，便于数字可读性
3: 下划线() 可以放置N个，但是不能把下划线() 开头
*/
println(“A=(A)”)
println(“B=(B)”)
println(“C=(C)”)
运行结果

A=110000
B=110000
C=110000

七.布尔类型

//
// main.swift
// 基本类型2

import Foundation

var A:Bool = true //bool 类型的取值 只能为 true false

var B:Bool = false

println(“A=(A)”)

println(“B=(B)”)
运行结果

A=true
B=false

八.元组

格式 :

变量或常量关键字 元组变量 ＝ （ 变量，变量, …）

说明：

1: 元组变量还是一个变量，只不过表现方式和其他变量不一样

2：()括号里面可以放入N个变量组成

例如：
import Foundation

/*
A是元组变量，（)里面放着 整形 和字符串

元组类型为 整形和字符串 组成
*/

var A = (1,”swift”)//元组变量A 由 整形和字符串 组成
println(A)
运行结果

(1, 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

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

最后总结（思维导图）