hello，这里是我学习官方文档时，记录的笔记，持续更新中~
Swift版本:2.2 Xcode版本:7.3
说明下，我这里是Playground文件，因此没有使用print等来显示打印值，
关于Playground，可以参考我的另一篇文章:Swift开发利器:PlayGround
这里内容是引导型的知识，帮助快速认识swift，具体的每个知识点，我随后会不断更新，然后更新成一个系列，和大家一块学习进步！
OK,上代码和注释：
func 初识swift() {//这是函数名，下面内容都是函数体中：
var num1 = 42
var str1 = "sds"
//1、创建一个常量，显示的指定类型为float，指定初始值为4
let float1:Float = 4
//2、字符串
//转字符串方法: String(**) 直接转string
let str2 = str+String(float1)
//转字符串方法: \(**) 直接放入字符串中
let fru = "http://blog.csdn.net/jiang314 \(float1+100) dsfsdd"
//3、字典数组
//使用[] 创建数组、字典
var arr1 = ["sd","wew","ss"]
arr1[0]="sdsd"//使用下标访问
arr1
var dic1 = ["as":"1","w":"2"]
dic1["as"]="http://blog.csdn.net/jiang314" //使用键访问
dic1
dic1[dic1.startIndex].0
dic1[dic1.startIndex].1
//3.1、创建空的数组，字典
let arr3 = [String]()
let arr4 = []
let dic3 = [String:Float]()
let dic4 = [:]
//4、控制流
//使用if switch来进行条件操作，使用for-in for while do-while来进行循环。（）可以省略，但是{}必须保留
//4.1、if语句，条件必须是布尔表达式
//有些变量的值是可选的，可能是一个具体的值，可也是nil。通过："变量?"
var optstr:String? = nil
if let name = optstr {
var gerr = "fee\(name)"
}else{
var gerr = "fee"
}
//4.2、switch语句 支持任意类型的数据的比较
//运行switch中匹配的句子后，会自动的退出switch，不用加break
var varq = "qw pper"
switch varq {
case "qqq":
let zz2 = "http://blog.csdn.net/jiang314"
case "sa1","13":
let zz2 = "sdsd"
case let x where x.hasSuffix("pper"):
let zz2 = "sdsdsd"//let 声明可以用来比较某部分的固定值
default:
let zz2 = "http://blog.csdn.net/jiang314"
}
//4.3、for in 遍历
let interestingNumbers = [
"Prime": [2, 3, 5, 7, 11, 13],
"Fibonacci": [1, 1, 2, 3, 5, 8],
"Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
for number in numbers {
if number>largest {
largest = number
}
}
}
largest
//4.4、while 条件可以条件前边或者后边
var n=2
while n<100{
n=n*2
}
n
var m=2
repeat {
m = m*2
} while m<100
m
//4.5、for循环
//可以使用..<表示【）\...表示【】，可以使用原始的<,>表示
var firstForLoop = 0
for i in 0...3 {
firstForLoop += i
}
firstForLoop
var secondForLoop = 0
for var i=0;i<=3;++i{
secondForLoop += i
}
secondForLoop
//5、函数闭包
//使用func声明函数，使用名字\参数调用函数，使用->指定返回值
func greet(name:String,day:String) ->String {
return"大家好，我博客地址是\(name),我的博客是: \(day)"
}
greet("http://blog.csdn.net/jiang314", day: "http://blog.csdn.net/jiang314")
//5.2、元组---------让一个函数有多个返回值
func getGasPrices(scrores:[Int]) -> (min :Int, max:Int, sum:Int) {
var min = scrores[0]
var max = scrores[0]
var sum = 0
for scro in scrores {
if scro>max {
max = scro
}else if scro<min{
min = scro
}
sum+=scro
}
return (min,max ,sum)
}
let aa = getGasPrices([12,232,33,-12,0,1111])
aa.max
aa.min
aa.sum
//5.3、函数带可变个数的参数，这些参数在函数内表现为数组的形式
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(42, 597, 12)
//5.4、函数可以嵌套
//通过嵌套来重构复杂的函数
func returnFifteen() -> Int {
var y = 10
func add() {
y += 5}
add()
return y
}
returnFifteen()
// 5.4、函数可以作为另一个函数的返回值
func make() -> (Int ->Int){
func addone (number:Int) ->Int{
return 1+number
}
return addone
}
var inc = make()
inc(7)
// 5.4 函数可以做为参数传入另外一个函数：
func has(list:[Int],cond:Int ->Bool) ->Bool{
for item in list {
if cond(item) {
return true
}
}
return false
}
func less(number:Int)->Bool {
return number<10
}
var numb = [20,12,23,333,11]
has(numb, cond: less)
// 5.4 函数实际上是一种特殊的闭包，可以使用{}创建一个匿名的闭包，使用in将参数和返回值的类型声明与闭包函数体进行分离
numb.map({
(number:Int)->Int in
let res = 3*number
return res
})//Map可以参考我的文章:Map方法
//可以通过参数位置，而不是名称来引用参数。这个方法在短的闭包里面非常有用。当一个闭包作为最后一个参数传给
//一个函数的时候，它可以直接跟在括号后面
let sortt = [-1, 5, 3, 12, 2].sort() { $0 > $1 }
sortt//实现排序，很简单的方法。
//不熟悉sort的可以参考我的另外一篇文章:sort方法
//6 对象和类
//6.1 使用class和类名来创建一个类，类中属性的声明和常量，变量声明一样，唯一的不同就是他们的上下文是类。同样，方法和函数声明一样
class Share {
var number = 0//类的属性
func sim() -> String {//类的方法
return "A SDVSV\(number)sss"
}
}
//6.2 创建实例 在类名后面加上括号。使用点语法访问其属性方法
var sha = Share()
sha.number = 12
var wwwqqw = sha.sim()
//6.3 上边少了 构造函数来初始化实例 init方法
class us {
var 地址:String = "http://blog.csdn.net/jiang314"//声明赋值
var 名字:String
init(名字:String){
self.名字 = 名字 //构造器赋值
}
func sim() -> String {
return "啊啊啊啊，这是啥：\(地址)啥啥啥"
}
}
// 注意：：每个属性都要赋值，无论是通过声明，还是通过构造器:init
// 6.4 创建子类
//如果需要在删除对象之前 进行一些清理工作。那么就需要使用deinit创建一个析构函数
//子类的定义方法，在类名后面加上父类的名字，用:分割，创建类的时候，并不需要一个标准的类，所以可以忽略父类
//子类如果要重写父类的方法，需要用override 标记。如果没有添加override，就重写的话，编译器会报错。同样，编译器也会检测，重写的方法，是否在父类里面。
class subq:us{
var side:Double
init(side:Double,名字:String){
self.side = side
super.init(名字:名字)
地址 = "http://blog.csdn.net/jiang314"
}
func area() -> Double {
return side*side
}
override func sim() -> String {
return "怎么可能呢，参考这里啊:\(地址)。。。66666"
}
}
let test = subq(side: 10,名字: "我的博客")
test.area()
test.sim()
// 6.5 set get 属性
class equ :us{
var sideL:Double = 0.0//设置子类的属性
init(sideL:Double,名字: String) {//调用init构造方法
self.sideL = sideL
super.init(名字: 名字)//父类构造方法
地址 = "http://blog.csdn.net/jiang314"
}
var per:Double{//子类的方法 set get
get {
return 3.0*sideL
}
set{
sideL = newValue/3.0
}
}
override func sim() -> String {//重写父类的方法
return "sdsdsd\(sideL)"
}
}
var tr = equ(sideL: 100,名字: "我的博客")
tr.per
tr.per = 9.99999999
tr.sideL
//注意上边的per构造器，执行了三步 1、设置子类声明的属性 2、调用父类的构造器 3、改变父类定义的属性值
//6.6 willset didset方法
//不需要计算属性的值，但是需要在设置新值之前，或者之后运行代码，使用will/didset
//参见文档demo
//6.7 类中的方法，和一般的函数有区别的，函数的参数名只在函数内部使用，但是方法的参数名，可以在调用方法的时候，显式的显示，默认情况下，方法的参数名和他在方法的内部是一样的，不过可以定义第二个名字，这个名字，只在方法的内部使用：
class Counter {
var count: Int = 0
func incrementBy(amount: Int, numberOfTimes times: Int) ->Int{//内部俩名 numberOfTimes times
count += amount * times
return 12
}
}
var counter = Counter()
counter.incrementBy(2, numberOfTimes: 7) //外部调用 numberOfTimes
// 6.8 ?的使用
//处理了变量的时候，可以在操作(方法，属性，子脚本)之前加？ 如果?之前是nil，那么?之后的会被忽略
//并且整个表达式返回nil，否则执行?之后的部分。因此，整个表达式是一个可选的部分
// 7 枚举
//使用enmu 来创建一个枚举。就像类和其他所有命名类型一样，枚举可以包含方法
enum Rank:Int {
case Ace = 1
case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten//2-10
case Jack, Queen, King//11-13
func simpleDescription() -> String {
switch self {
case .Ace:
return "ace"//1
case .Jack:
return "jack"//11
case .Queen:
return "queen"//12
case .King:
return "king"//13
case .Three:
return "three"//3
default:
return String(self.rawValue)
}
}
}
let ace = Rank.Ten
let acee = ace.rawValue
let accc = ace.simpleDescription()
// rawValue: 对应原始值。使用之可以在原始值与实际值之间切换
//上边的例子里面，枚举的原始值 类型是 int ，只需要设置第一个原始值，剩下的会按照顺序进行赋值。
//也可以使用浮点数或者字符串作为枚举的原始值
if let convertedRank = Rank(rawValue: 3) {
let threeDescription = convertedRank.simpleDescription()
}
if let convertedRank = Rank(rawValue: 13) {
let threeDescription = convertedRank.simpleDescription()
}
//枚举成员值是实际值，实际上原始值没有什么意义的话，不需要设置
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func simpleDescription() -> String {
switch self {
case .Spades:
return "spades"
case .Hearts:
return "hearts"
case .Diamonds:
return "diamonds"
case .Clubs:
return "clubs"
}}}
let hearts = Suit.Hearts
let heartsDescription = hearts.simpleDescription()
//8 结构体
//使用struct来创建结构体，和类有很多的相似处，比如方法和构造器。最大的区别是，结构体在于传值，类是传引用
struct Card {
var rank: Rank//里面是枚举
var suit: Suit//枚举
func simpleDescription() -> String {
return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
}
}
let threeOfSpades = Card(rank: .Three, suit: .Spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()
//日出日落。注意如何从ServerResponse 里面获取时间
enum ServerResponse {
case Result(String, String)
case Error(String)
}
let success = ServerResponse.Result("6:00 am", "8:09 pm")
let failure = ServerResponse.Error("Out of cheese.")
switch success {
case let .Result(sunrise, sunset):
let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
let serverResponse = "Failure... \(error)"
}
// 9 协议
//使用protocol声明协议
//协议 写在header
protocol ExampleProtocol {
var simpleDescription: String { get }
mutating func adjust()
}
//类，枚举，结构体 都可以实现协议
class SimpleClass: ExampleProtocol {
var simpleDescription: String = "A very simple class."
var anotherProperty: Int = 69105
func adjust() {
simpleDescription += " Now 100% adjusted."
}}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure: ExampleProtocol {
var simpleDescription: String = "A simple structure"
mutating func adjust() {
simpleDescription += " (adjusted)"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
//注意声明 SimpleStructure时候，mutating关键字用来标记一个会修改结构体的方法，
// SimpleClass:不需要声明标记任何方法，因为类中会经常修改任何方法的
// 当处理类型是协议的值时，协议外的定义的方法，不可用。也就是，不能调用协议外(通过扩展等定义的)的方法，属性
//10 扩展
//使用 extension 来为现有的类型添加新功能，可以使用扩展在别处修改定义，甚至从外部库或者框架引入类型，使得这个类型遵循某个协议。 写在header
//扩展
extension Int:ExampleProtocol{
var simpleDescription:String {
return "the num \(self)"
}
mutating func adjust(){
self += 42
}
}
12.simpleDescription
//11 泛型
//在尖括号 里面写一个名字来创建一个泛型函数或者泛型
// func repeat<ItemTypeq>(item: ItemTypeq, times: Int) -> ItemTypeq[] {
// var result = ItemType[]()
// for i in 0..times {
// result += item
// }
// return result
// }
// repeat("knock", 4)
//以上是旧的方法，最新的如下:
//详情参见 https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/GenericParametersAndArguments.html
func simpleMax<T: Comparable>(x: T, _ y: T) -> T {
if x < y {
return y
}
return x
}
simpleMax(17, 42)
simpleMax(3.14159, 2.71828)
//创建泛型类，枚举，结构体
enum Op<T>{
case None
case Some(T)
}
var poss:Op<Int> = .None
poss = .Some(100)
//在类型名后面，使用where 来指定对类型的需求，比如限定类型实现某一协议，限定两个类型是相同的，或者限定某个类必须要有特定的父类
func anyCommonElements <T, U where T: SequenceType, U: SequenceType, T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (lhs: T, rhs: U) -> Bool {
for lhsItem in lhs {
for rhsItem in rhs {
if lhsItem == rhsItem {
return true
}}}
return true}
anyCommonElements([1,2,3], rhs: [3])
//简单起见，可以忽略where，只在冒号后面，写协议或者类名
//<T: Equatable> is the same as writing <T where T: Equatable>.
}//函数体结束
初识swift()
最后：
2、本文的代码：代码
3、swift官方文档:PDF版
4、swift官方文档: 中文版
5、其他知识，还请参考，本人的Swift开发资源库系列文章。
6、欢迎大家加swift开发者群:179235963
1717
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
