<span style="font-size:18px;">// Playground - noun: a place where people can play
import UIKit
//HelloWorld
var str = "Hello, playground"
//常量可以改变值
var myVariable = 42
myVariable = 50
let myConstant = 42
//指定数据类型
let floatNumber : Float = 4
//使用强制转换
let label = "the label is"
let width = 94
let lanelwidth = label + String(width)
//使用双引号中的来转换
let apples = 3
let oranges = 5
let appleSummary = "i have (apples) apples"
let orangeSummary = "i have (oranges) oranges"
//自动识别数据类型加斜杠转换
let somebody = "Alice"
let age = 23.5
let hellosomebody = "(somebody) is (age)"
//数组的初始化以及赋值
var shoppingList = ["Alice", "Dylan"]
shoppingList[1] = "Petit Alice"
//字典的初始化以及赋值
var occupations = [
"male" : "Alice",
"female" : "Dylan"
]
occupations["male"] = "Alice.Petit"
//初始化一个空的数组或者字典
let emptyArray = [String]()
let emptyDictionary = [String : Float]()
//初始化一个自动识别类型的字典或者数组
let emptyArray_auto = []
let emptyDictionary_auto = [:]
//控制流 不能省略大括号
let indivdualScores = [75, 42, 103, 87, 12]
var teamScore = 0
for score in indivdualScores {
if score > 50 {
teamScore += 3
} else {
teamScore += 1
}
}
teamScore
let emptyA = ["key" : "value"]
emptyA
//在if条件中,条件必须是bool表达式 输入一个直接score会出错的
//使用let来标记
var optionalString : String? = "Hello"
optionalString == nil
var optionalName : String? = "John Appleseed"
var getting = "Hello"
optionalName = nil
if let name = optionalName {
getting = "Hello, (name)"
} else {
getting = "hello, Alice"
}
//switch
let vegetable = "red pepper"
switch vegetable {
case "celery" :
let vegetableComment = "add some"
case "cummber", "watercress" :
let vegetableComment = "this would make a good tea"
case let x where x.hasSuffix("papper"):
let vegetableComment = "is it a spicy (x)"
default :
let vegetableComment = "everything tastes good in soup"
}
//碰到匹配的句子后, switch不会继续往前走
let interstingNumbers = [
"prime" : [2, 3, 4, 6],
"Fibonacci" : [1, 1, 2, 3],
"Square" : [1, 4, 5]
]
var largest = 0
var maxtype = ""
for (kind, numbers) in interstingNumbers {
for number in numbers {
if number > largest {
largest = number
maxtype = kind
}
}
}
largest
maxtype
//while
var n = 2
while n < 100 {
n = n * 2
}
n
var m = 2
do {
m = m * 2
} while m < 100
m
//while do 不会多循环一次的 他们是等价的
//...<
var firstForLoop = 0
for i in 0..<4 {
firstForLoop += i
}
firstForLoop
var secondForLoop = 0
for var i = 0; i < 4; i++ {
secondForLoop += i
}
secondForLoop
var thirdForLoop = 0
for i in 0...4 {
thirdForLoop += i
}
thirdForLoop
//func
func greet(name: String, day :String) ->String {
return "Hello, (name), today is (day)"
}
greet("Alice", "Tuesday")
func whateating(name : String) -> String {
return "(name) eat what?"
}
whateating("Alice")
//使用元组让一个函数返回多个值
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
}
if score < min {
min = score
}
sum += score
}
return (min, max, sum)
}
let staticArray = [1, 2, 3, 4, 5]
calculateStatistics(staticArray)
//返回值可以用点语法 单独取到 也可以用位置
calculateStatistics(staticArray).sum
calculateStatistics(staticArray).0
//函数可以带有可变个数的参数
func sumOf(numbers : Int...) ->Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf(1, 2)
sumOf()
sumOf(1, 2, 3, 4, 5)
//计算参数平均值的联系
func acr(number : Int...) ->Float {
var sum = 0
for num in number {
sum += num
}
return Float(sum) / Float(number.count)
}
acr(1, 2, 3)
acr(3, 4)
//函数可以嵌套 被嵌套函数可以访问外侧函数的变量 可以嵌套函数来构成一个太长或者太复杂的函数
func returnFifteen() ->Int {
var y = 10
func add() {
y += 5
}
add()
return y
}
returnFifteen()
//函数可以作为另一个函数的返回值
func makeIncrementer() ->(Int ->Int) {
func addOne(number : Int) -> Int {
return 1 + number
}
return addOne
}
var increment = makeIncrementer()
increment(7)
//函数可以当做参数 传入另一个函数
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, 2, 12]
hasAnymatches(numbers, lessThanTen)
//函数实际上是一种特殊闭包 使用{} 来创建一个匿名的闭包 使用int将参数和返追只类型声明与闭包函数进行分离
numbers.map({
(number: Int) -> Int in
if number % 2 != 0 {
return 0
}
return 1
})
let mappedNumbers = numbers.map ({
number in 3*number
})
mappedNumbers
let sortedNumbers = sorted(numbers) {
$0 > $1
}
//对象和类
class Shape {
var numberOdSides = 0
let testGetNumber = 0
func setNumber(number : Int) {
numberOdSides = number
}
func simpleDescription() ->String {
return "A shape with (numberOdSides) sides"
}
}
var shape = Shape()
shape.setNumber(10)
shape.simpleDescription()
//init
class NameShape {
var numberOfSides : Int = 0
var name:String
init(name: String, number: Int) {
self.name = name
self.numberOfSides = number
}
func simpleDescriptin() ->String {
return "A (name) with (numberOfSides) sides"
}
}
var nameShpe = NameShape(name: "Alice", number: 20)
nameShpe.simpleDescriptin()
//继承
class Square: NameShape {
var sidelength: Double
init(sidelength: Double, name: String, number: Int) {
self.sidelength = sidelength
super.init(name: name, number: number)
}
func area() -> Double {
return sidelength * sidelength
}
override func simpleDescriptin() -> String {
return "a Square with Sides of Length (sidelength)"
}
}
//getter setter
class EquilaterTrabgle: NameShape {
var sideLengths:Double = 0.0
init(side: Double, name: String, number:Int) {
self.sideLengths = side
super.init(name: name, number: number)
}
var perimter: Double {
get {
return 3 * sideLengths
}
set {
sideLengths = newValue / 3.0
}
}
override func simpleDescriptin() -> String {
return "an square triagle with (sideLengths)"
}
}
var triangle = EquilaterTrabgle(side: 3.1, name: "Alice", number: 3)
triangle.perimter
triangle.perimter = 9.9
triangle.sideLengths
triangle.simpleDescriptin()
//默认情况 方法参数名和他们在方法内部的名字一样
class counter {
var count : Int = 0
func incrementBy(amount: Int, numberOfTimes times: Int) {
count += amount * times
}
}
var count = counter()
count.incrementBy(2, numberOfTimes: 7)
//处理变量可选值的时候 你可以在操作之前加? 之前的值是nil的话 那么后面的东西将不会被执行 否则 ? 后边的东西被运行 这种情况下 整个表达是只有一个可选值
let optionalSqare: Square = Square(sidelength: 2, name: "Alice", number: 3)
let sidelength = optionalSqare.sidelength
//枚举和结构体
enum Rank: Int {
case Ace = 1
case Two, Three, Four, Five
case Jack, Queen
func simpleDescription() ->String {
switch self {
case .Ace:
return "ace"
case .Jack:
return "jack"
case .Queen:
return "queen"
default:
return String(self.rawValue)
}
}
}
let ace = Rank.Ace
let aceRowValue = ace.rawValue
ace.simpleDescription()
//写一个函数 来比较两个Rank的值
enum Ranks:Int {
case one = 1
case two = 2
case three = 3
func sub(number1:Int, number2: Int) ->Int{
return number1 > number2 ? number1 : number2
}
}
let one = Ranks.one
one.sub(10, number2: 2)
//使用toRow 和fromRow函数在原始值和枚举值之间轻松切换
if let convertedRank = Rank(rawValue: 3) {
let threeDescription = convertedRank.simpleDescription()
threeDescription
}
//枚举的成员是实际值并不是原始值的另一种表达方法 实际上 如果原始之没有意义 你不需要设置
enum Suit {
case Spades, Hearts, Diamonds, Clubs
func simleDescription() ->String {
switch self {
case .Spades:
return "spa"
case .Hearts:
return "hearts"
case .Diamonds:
return "dia"
case .Clubs:
return "clubs"
}
}
}
let hearts = Suit.Hearts
let heartsDescription = hearts.simleDescription()
//定义一个结构体 接受上边传来的东西
struct Card {
var rank : Rank
var suit : Suit
func sipleDescription() -> String {
return "(rank), (suit)"
}
}
let thspeed = Card(rank: .Three, suit: .Spades)
let thspeeds = thspeed.sipleDescription()
thspeeds
thspeed
//通过枚举 却别正确错误信息
enum ServerResponse {
case Result(String, String)
case Error(String)
}
let success = ServerResponse.Result("Alice", "Dylan")
let failure = ServerResponse.Error("Error")
switch success {
case let .Result(sunrise, sunset):
let serverResponse = "(sunrise), (sunset)"
case let .Error(error):
let serverResponse = "Failure .. (error)"
}
//协议和扩展
//首先 使用protocal来声明一个协议
protocol ExampleRrotocol {
var simpleDescription: String {
get
}
mutating func adjust()
}
//类 枚举 结构体 都可以实现协议
class SimoleClass: ExampleRrotocol {
var simpleDescription: String = "A very petit girl"
var anotherpRroperty: Int = 69105
func adjust() {
simpleDescription += "Alice"
}
}
var a = SimoleClass()
a.adjust()
let aDescription = a.simpleDescription
struct SimpleStructure : ExampleRrotocol {
var simpleDescription: String = "Alice"
mutating func adjust() {
simpleDescription += ".Dylan"
}
}
var b = SimpleStructure()
b.adjust()
let bDescription = b.simpleDescription
</span>