Swift入门-Day 1
2016-03-13 23:11
218 查看
一.swift语言基本类型
整形 Int
浮点类型 Float Double
字符类型 String
集合类型 Array Dictionary
注意点:
1: 基本类型 首写字母 要大写。
2: 基本类型不能直接定义 类型变量 (这和其他语言有所不同)
例如:Int A=10 //错误,基本类型不能直接定义变量
二.变量
定义变量的关键字是 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 =
976f
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 {} 中方法
}
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
最后总结(思维导图)
整形 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 =
976f
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
最后总结(思维导图)
相关文章推荐
- Swift之一步一步带你封装一个本地缓存库
- Ubuntu 15.10安装Swift
- swift 之xib自定义view可视化到storyboard
- Swift 2.0 单例的用法
- 在Swift中使用JavaScript的方法和技巧
- 对照Java学习Swift--基础部分
- IOS·Swift 集合类型之字典类型排序
- Swift-predecessor(), successor(), advancedBy()
- swift 2.0改变的部分
- [译]raywenderlich.com官方的swift风格指南(二)
- [译]raywenderlich.com官方的swift风格指南(一)
- Swift语言工厂设计模式和抽象工厂设计模式
- 15--swift之内存管理
- 16--swift之内存管理进阶
- 17--swift之可选链
- swift:swift与oc代码互相调用
- Swift - Delegate
- oc swift 混编
- iOS8 Core Image In Swift:视频实时滤镜
- Swift 基础学习(内存管理二)