SWIFT基础语法 (一)

SWIFT的main函数是隐藏的main函数，运行的时候会直接被调用，没有分号（加上也不会报错），用let定义常量，var定义变量。

---

常量和变量

• 常量和变量

let myValue = 40
var anotherValue = 30
anotherValue = 20

• 编译器可以通过你的赋值判断你所创建的常量或变量的类型。如果要是不能准确判断的话，就在变量名后指定类型。

let valueDouble = 2.0
let valueInteger = 2
let valueDouble:Double = 2

值转化类型

• 值转化类型

let strLable = "The width is"
let width = 94 
let withLable = strLable + String(width)
//还有一种非常方便的方法，在字符串里添加值，在圆括号中书写值，并在括号前添加反斜线 \
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples)apples"
let fruitSummary = "I have \(apples + oranges) piece of fruit"

字典、数组

• 使用[]来创建数组和字典，通过方括号中的索引或键名来访问其中的元素。

var shoppingList = ["a","b"]
shoppingList[1]="26 of b" //修改数组中的元素值
var occupations = ["name":"candy","age":19]
occupations["job"] = "iOS"  //向字典里添加键值对

//用初始化语法创建一个空的数组或者字典
let emptyArray = String[]()
let emptyDictionary = Dictionary<String,Float>()

//如果无法推断类型信息，可以用[]来创建一个空数组，使用[:]来创建一个空字典。
var shoppingListArray = []
var shoppingListDictionary = [:]

循环语句

• 用if和switch来作为条件控制，使用for-in、for、while、do-while来构造循环。包装条件或者循环变量的圆括号可以省略，但是主体外的花括号是必须的。

let individualScores = [76,78,98,0]
var teamScore = 0
var score in individualScores{
if score > 50{
    teamScore +=3
else{
    teamScore +=1 
  }
}
print("%@",teamScore)
//在if语句中，条件必须是一个布尔表达式-------这表示如“if score{。。。。。}”这样写的代码是错误的，并不能隐式的同0进行比较。

• 可以同时使用if 和let来防止值的丢失。这些值是可选的，可通过包含另一个值或者包含nil来指明该值不存在。通过在类型后添加问号来标记一个值为可选。

var optionalString:String? = "hello"
optionalString = nil
var optionalName:String? = "John"
if let name = optionalName
{
//如果optionalName不是nil的话， let name = optionalName 为true
   NSLog("hello"+name)
  }
  //如果可选值为nil，则条件判断为false，花括号中的代码会被跳过。反之，可选值去包装并且赋值给let后面的常量（去包装：不再是可选的，成为了一个确切的值，不再存在为空的情况），使得去包装的值可以在代码块内访问。

switch

• switch支持所有类型的数据，以及多种比较运算—没有限制必须是整数，也没有限制必须相等。

let vegetable = "red pepper"
switch vegetable{
     case "celery":
     let vegetableComment = "hahahha"
     case "red pepper":
     let vegetableComment = "red pepper"
     case let x where x.hasSuffix("pepper"):
     let vegetableComment = "is it a spicy \(x)?"
     default:
     let vegetableComment = "Everything tastes good in soup."
 }
 //执行完匹配到的case后，程序会跳出switch，而不是继续执行下一个case，所以不需要在case的代码后添加break来跳出switch。

• 使用for-in来迭代字典中的元素，需要提供一对名字来访问每一个键值对。

let interestingNumbers = [
                             "prime":[2,3,4,5,5],
                             "Fibonacci":[2,4,56,5],
                             "Square":[2,5,7,8,6,4]
  ]
  var largest = 0
  for (kind,numbers) in interestingNumbers{
       for number in numbers{
             if number > largest{
                  largest = number
                  }
              }
      }

• 使用while来重复执行一个代码块直到条件改变，循环条件可以放到最后，用于保证循环至少被执行一遍。

var n = 2
while n < 100 {
     n = n*2
   }

var m = 2
do{
    m = m *2
   }while m < 100

• 可以在循环中维持一个索引。一种方法是使用..来表示一段索引区域，另一种方法是显式的指明初始值、判断条件以及每次循环的增量。以下的两个循环做的是同样的事情：

var firstForLoop = o
for i in 0..3
{
    firstForLoop += i
 }

var secondForLoop = 0
for var i = 0; i < 3; i++ {
    secondForLoop += 1
 }
 //使用..来创建一个或略最高值的取值区间，使用...构造的范围则同时包含最高值和最低值。

函数、闭包

• 函数和闭包：使用func来声明一个函数。通过在函数名后面添加包含参数列表的花括号来执行函数，使用->来分离参数和返回类型。

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

元组

• 使用元组（tuple）来返回多个值

func getGasPrices() -> (String,Double,Int){
        return ("name",168.0,19)
    }

• 函数可以有可变长度的参数，通过数组来包含它们。

func sumOf (numbers:NSArray) -> Int {
       var sum = o
       for number in numbers{
           sum += number
           }
          return sum
}

• 函数可以嵌套。嵌套函数可以访问在外部函数中声明的变量。可以使用嵌套函数来包装冗长和复杂的代码。

funcc returnFifteen() -> Int{
     var y = 10

     return  add(y)
}
func add(number:Int){
   number += 5
}

• 一个函数可以使用另一个函数作为参数。

fun 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,3]
 hasAnyMatches(numbers,lessThanTen)