LearningSwift

LearningSwift.swift

import UIKit

print("hello world")
let myConstVar = 2; //let定义常量
var myVar = 3 ;//var定义变量
let explicitDouble:Float=4

let apple = 3.1415
let str = "\(apple) apple"
var array=["1","2","3"];
array[2]
var dict = [
	"a":"c",
	"b":"d"
]
//创建空数组和空字典
let emptyArray1 = [String]()
let emptyArray2 = [String:Float]()


let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
	if score > 50 {
		teamScore += 3
	} else {
		teamScore += 1
	}
}
print(teamScore)

//可选值
let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"


var optionalVar:String? = "hello"
print(optionalVar == nil)
var optionalName:String? = nil//"my name"
var greeting = "hello"
if let name = optionalName{
	greeting = "hello \(name)"
}else{
	greeting = "false"
}

let vegetable = "red pepper"
switch vegetable {
case "celery":
	let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
	let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
	let vegetableComment = "Is it a spicy \(x)?"
default:
	let vegetableComment = "Everything tastes good in soup."
}

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
var name = ""
for (kind, numbers) in interestingNumbers {
	for number in numbers {
		if number > largest {
			largest = number
			name = kind
		}
	}
}
print(largest)
print(name)

var n = 2
while n < 100 {
	n=n*2
}
print(n)

var m = 2
repeat {//do-while is deprecate
	m=m*2
} while m < 100
print(m)

var firstForLoop = 0;
//..<不包含上界
//...包含上界
for i in 0...4 {
	firstForLoop += i }
print(firstForLoop)

var secondForLoop = 0
for var i = 0; i < 4; ++i {
	secondForLoop += i }
print(secondForLoop)

func greet(name:String , day:String) ->String{
	return "Hello \(name) , today is \(day)"
}
greet("Bob",day: "Tuesday")

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
	var min = scores[0]
	var max = scores[0]
	var sum = 0
	for score in scores { if score > max {
		max = score
	} else if score < min {
		min = score }
		sum += score }
	return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.1)


func sumOf(numbers: Int...) -> Int { var sum = 0
 for number in numbers {
	sum += number
	}
	return sum
}
sumOf()
sumOf(42, 597, 12)


func returnFifteen() -> Int {
	var y = 10
	func add() {
		y += 5
	}
	add()
	return y
}
returnFifteen()

//函数可以作为返回值
func makeIncrementer() -> (Float -> Float) {
	func addOne(number: Float) -> Float {
		return 1.0 + number
	}
	return addOne
}
var increment = makeIncrementer()
increment(7.1)

func hasAnyMatches(list: [Int], condition: Int -> Bool) -> Bool {
	for item in list {
		if condition(item) {
			return true
		}
	}
	return false
}
func lessThanTen(number: Int) -> Bool {
	return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers,condition: lessThanTen)

//函数其实是特殊的闭包，可以用{}创建匿名闭包
numbers.map({
	(number: Int) -> Int in
	let result = 3 * number
	return result
})

//单个语句的闭包可以把它语句的值当做结果返回
let mappedNumbers = numbers.map({
	number in 3 * number
})
mappedNumbers

//可以通过参数位置而不是参数名字来引用参数
let sortedNumbers = numbers.sort {$0 > $1}
print(sortedNumbers)


class NamedShape {
	var numberOfSides: Int = 0
	var name: String
	init(name: String) {
		self.name = name
	}
	func simpleDescription() -> String {
		return "A shape with \(numberOfSides) sides."
	}
}

class Square: NamedShape {
	var sideLength: Double
	init(sideLength: Double, name: String) {
		self.sideLength = sideLength
		super.init(name: name)
		numberOfSides = 4
	}
	func area() ->  Double {
		return sideLength * sideLength
	}
	override func simpleDescription() -> String {
		return "A square with sides of length \(sideLength)."
	}
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

class EquilateralTriangle: NamedShape {
	var sideLength: Double = 0.0
	init(sideLength: Double, name: String) {
		self.sideLength = sideLength
		super.init(name: name)
		numberOfSides = 3
	}
	var perimeter: Double {
		get {
			return 3.0 * sideLength
		}
		set {
			sideLength = newValue / 3.0
		}
	}
	override func simpleDescription() -> String {
		return "An equilateral triagle with sides of length \(sideLength)."
	}
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)
//注意 EquilateralTriangle 类的构造器执行了三步:
//1. 设置子类声明的属性值
//2. 调用父类的构造器
//3. 改变父类定义的属性值。其他的工作比如调用方法、getters和setters也可以在这个阶段完成。
//如果你不需要计算属性,但是仍然需要在设置一个新值之前或者之后运行代码,使用 willSet 和 didSet 。 
//比如,下面的类确保三角形的边长总是和正方形的边长相同。
class TriangleAndSquare {
	var triangle: EquilateralTriangle {
		willSet {
			square.sideLength = newValue.sideLength
		} }
	var square: Square {
		willSet {
			triangle.sideLength = newValue.sideLength
		}
	}
	init(size: Double, name: String) {
		square = Square(sideLength: size, name: name)
		triangle = EquilateralTriangle(sideLength: size, name: name)
	}
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength


//enum
enum Rank: Int {
	case Ace = 1
	case Two
	case Three, Four, Five, Six, Seven, Eight, Nine, Ten
	case Jack, Queen, King
	func simpleDescription() -> String {
		switch self {
		case .Ace:
			return "ace"
		case .Jack:
			return "jack"
		case .Queen:
			return "queen"
		case .King:
			return "king"
		default:
			return String(self.rawValue)
		}
	}
}
let ace = Rank.Ace
let ten = Rank.Ten
print(ten)
let aceRawValue = ace.rawValue

if let convertedRank = Rank(rawValue: 11) {
	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();


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()


//使用 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()


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.")

//注意如何从 ServerResponse 中提取日升和日落时间并用得到的值用来和 switch 的情况作比较。
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)"
}
switch failure {
case let .Result(sunrise, sunset):
	let serverResponse = "Sunrise is at \(sunrise) and sunset is at \(sunset)."
case let .Error(error):
	let serverResponse = "Failure...  \(error)"
}

//使用 protocol 来声明一个协议。
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

extension Int: ExampleProtocol {
	var simpleDescription: String {
		return "The number \(self)"
	}
	mutating func adjust() {
		self += 42 }
}
print(7.simpleDescription)

let protocolValue: ExampleProtocol = a
print(protocolValue.simpleDescription)
// print(protocolValue.anotherProperty)  // Uncomment to see the error

//泛型
func repeatItem<Item>(item: Item, numberOfTimes: Int) -> [Item] {
	var result = [Item]()
	for _ in 0..<numberOfTimes {
		result.append(item)
	}
	return result
}
repeatItem("knock", numberOfTimes:4)

// Reimplement the Swift standard library's optional type
enum OptionalValue<Wrapped> {
	case None
	case Some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)

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 false
}
anyCommonElements([1, 2, 3], rhs: [3])
//<T: Equatable> <T where T: Equatable>是等价的。