Playground -swift01基础学习

//: Playground - noun: a place where people can play
//
//  test1.swift
//  swift02
//
//  Created by 张建 on 16/9/23.
//  Copyright © 2016年 zhangjian. All rights reserved.
//

import UIKit

var str = "Hello, playground"


//定义变量用var 常量用let
var myVar = 50
let myLet = 100

let myDouble:Double = 700
let myLett:Float = 4

let label = "The width is"
let width = 250
//会将width类型转化为String类型
let widthLabel = label + String(width)
//以下做法会出现类型不同,编译器无法通过,报错.
//let widthLabel = label + width

//有种更简单的方法是:把值写到括号中,并且在括号之前写一个反斜杠.例如
let apple = 5
let orange = 6
let appleSum = "I have \(apple)apples."
let fruitSum = "I have \(apple + orange)pieces of fruit."


//练习: 使用 \() 来把一个浮点计算转换成字符串,并加上某人的名字,和他打个招呼

let myApp = "My Name is"
let myName = "chenmeng"
let myRmb:Double = 100
let myAppSum = myApp + myName + "I have \(myRmb)yuan."

//使用方括号 [] 来创建数组和字典,并使用下标或者键(key)来访问元素。

var shoppingList = ["catfish", "water", "tulips", "blue paint"];
//shoppingList[1] = "bottle of water"

var occ = [
"shanxi":"datong",
"henan":"zhenzhou"
]

//occ["shanxi"] = "public"

//要创建一个空数组或者字典,使用初始化语法。

let emptyArray = [String]()
let emptyDictionary = [String:Float]()
//如果类型信息可以被推断出来,你可以用 [] 和 [:] 来创建空数组和空字典——就像你声明变量或者给函数传参数 的时候一样。
*/



//使用 if 和 switch 来进行条件操作,使用 for-in 、 for 、 while 和 repeat-while 来进行循环。包裹条件和循环 变量括号可以省略,但是语句体的大括号是必须的。
//以下语句会报错,因为if语句中,条件必须是一个布尔表达式
//let mathScores = [88,99,56,89,70,46]
//var teamScore = 0
//for score in mathScores{
//
//      if score > 50{
//              teamScore += 3
//      }else{
//              teamScore +=5
//      }
//
//}
//
//print(teamScore)

//你可以一起使用 if 和 let 来处理值缺失的情况。这些值可由可选值来代表。一个可选的值是一个具体的值或者是 nil 以表示值缺失。在类型后面加一个问号来标记这个变量的值是可选的。

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

//使用 while 来重复运行一段代码直到不满足条件。循环条件也可以在结尾,保证能至少循环一次。

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

var m = 2
repeat {
  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 j = 0; j < 4; ++j{
      secondForLoop += j
}
print(secondForLoop)




//使用 func 来声明一个函数,使用名字和参数来调用函数。使用 -> 来指定函数返回值的类型。

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

greet("zhangjian", day: "Tuesday")

//练习: 删除 day 参数,添加一个参数来表示今天吃了什么午饭。
func eat(name:String, food:String) ->NSString{
      return "Hello \(name),eat \(food)."
}
eat("Jackchen", food: "apple")

//使用元组来让一个函数返回多个值。该元组的元素可以用名称或数字来表示
func calculateStatistics(scores:[Int])->(min:Int, max:Int, sum:Int, ave:Int){
      //使用初始化
      var min = scores[0]
      var max = scores[0]
      var sum = 0
      var ave = 0
     
      for score in scores{
              if score > max{
                     
                      max = score
              }else if score < min{
                      min = score
              }
             
              sum += score
              ave = sum/scores.count
      }
      return (min,max,sum, ave)
}

let statistics = calculateStatistics([5, 3, 100, 99, 3])
print(statistics.sum)
print(statistics.2)
print(statistics.min)
print(statistics.max)
print(statistics.0)
print(statistics.1)
print(statistics.ave)

//函数可以带有可变个数的参数,这些参数在函数内表现为数组的形式:
func sumOf(numbers:Int...)->Int{
      var sum = 0
      for number in numbers{
              sum += number
      }
      return sum
}

sumOf()
sumOf(33, 33, 55, 34)

//函数可以嵌套。被嵌套的函数可以访问外侧函数的变量,你可以使用嵌套函数来重构一个太长或者太复杂的函
//数。
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(10)

//函数也可以当做参数传入另一个函数。
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, 50, 3, 22]
hasAnyMatches(numbers, condition: lessThanTen)

//函数实际上是一种特殊的闭包:它是一段能之后被调取的代码。闭包中的代码能访问闭包所建作用域中能得到的变 量和函数,即使闭包是在一个不同的作用域被执行的 - 你已经在嵌套函数例子中所看到。你可以使用 {} 来创建一 个匿名闭包。使用 in 将参数和返回值类型声明与闭包函数体进行分离。

numbers.map ({
      (number:Int) -> Int in
      let result = 3 * number
      return result
})
//有很多种创建更简洁的闭包的方法。如果一个闭包的类型已知,比如作为一个回调函数,你可以忽略参数的类和返回值。单个语句闭包会把它语句的值当做结果返回。
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)


//使用 class 和类名来创建一个类。类中属性的声明和常量、变量声明一样,唯一的区别就是它们的上下文是 类。同样,方法和函数声明也一样。
class Shape{
      var numberOfSides = 0
      func simpleDescription() ->String {
              return " A Shape with \(numberOfSides)sides..."
      }
}

//要创建一个类的实例,在类名后面加上括号。使用点语法来访问实例的属性和方法。
var shape = Shape()
shape.numberOfSides = 10
var shapeDescription = shape.simpleDescription()

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