下面是本人对objc学习转向swift的一些基本知识的心得，如有错误的地方，希望大家能够帮忙指出
首先最明显的地方就是语法规范了，swift中语句结尾没有分号，而且swift将点语法体现的淋漓尽致，整篇代码中的方法的调用都是用的点语法，一点到底，比如以下方法调用的代码

var dict: Dictionary<String, String> = [:]
dict = ["b" : "c"]
dict.removeValueForKey("b")

然后在swift随处可见的var 和 let 两个关键词 var 声明变量的 let 声明常量的
下面就对swift中的部分基本语法简单分享以下吧
一、各种数据类型的常量、变量的定义
因为之前说过常量与变量的差别主要是一个使用的var 另一个是 let 所以以下罗列几个var修饰的吧

var num:Int = 88
var num2:Float = 13.3
var str:String = "阿呆是个好同志"
var c:Character = "x"
var isTrue:Bool = true

通过以上的格式可以看出 指明数据类型常量的声明格式如下：
**var 变量名:数据类型 = 值 **
在oc中BOOL的值是YES和NO 但是swift中则是true和false 由于swift是强语言，所以不支持隐式转换，下面对swift中字符串的简单操作

let str = "hello"
// 字符串长度
str.characters.count
str.lengthOfBytesUsingEncoding(NSUTF8StringEncoding)
// 大小写转换
str.uppercaseString
str.lowercaseString
// 拼接
"123\(str)4555"

二、数组和字典

// 不可变数组
let array1 = ["A","B","C","D"]
// initWith/init在swift里面全部转换成()
let array2 = [String]()
//元素个数.count
//数组遍历for-in (明确的指出数组的类型)
for temp in array1 as [String]{
print(temp)
}
//元组遍历
for (index,value) in array1.enumerate(){
print("index = \(index),value = \(value)")
}

//可变数组
var mutableArray = [String]()
mutableArray.append("hello")
mutableArray.append("world")
print(mutableArray)
mutableArray.removeFirst(1)
print(mutableArray)

//字典Dictionary
let dict = ["key1":"value1","key2":"value2","key3":"value3"]
print(dict)
//通过key值访问value值
print(dict["key1"])
// for-in遍历
for (key,value) in dict
{
print("key = \(key), value = \(value)")
}
//可变字典
var dict3 = ["key":"value"]
// (合并)
for (tempkey,tempValue) in dict {
//如果key存在则是一个更新键值对操作，否则是一个增加键值对操作
dict3[tempkey] = tempValue
}
print(dict3)

三、If语句

// 可选类型的条件分支
let str:String? = "hello"
// 1. if-let是对可选类型的判断，如果可选类型为nil，则不执行代码块，如果不为空则用tempStr来接收此刻这个可选类型的解包的值
if let tempStr = str {
  print(tempStr)
}
// 2. if-let-where 跟if-let相似，where是对前面定义的这个局部变量再做一层判断
if let tempStr = str where tempStr.characters.count > 2{
  print("tempStr.length = \(tempStr.characters.count)") 
}
// 3.guard-let-else
// 如果可选类型str为nil，则执行code代码块，最后一定要return，如果不为nil则强制解包后的值赋给tempStr，这样在{}外面就可以使用tempStr
guard let tempStr = str else{
  code...
  return
}

四、switch
switch 不局限判断整型，可以是浮点型，也可以是字符串
switch后面的小括号可以省略，大括号不能省略
case后面至少要有一条执行语句 并且case后面的大括号可以省略，break可以不写，不会造成贯穿
default一定要写，并且只能写在最后

let f = 3.2
switch f {
case 3.0:
  print("a")
 case 3.1:
  print("aa")
case 3.2:
  print("aaa")
default:
  print("unknown")
}

五、for循环
该写法是在swift2.2的时候被废弃掉

for (var i = 0;i < 5;i++){
  
}

现在采用以下写法
0..<5相当于 [0,5)
0...5相当于 [0,5]

for i in 0..<5{
  print("i = \(i)")
}

六、枚举
枚举值可以关联浮点，字符串,没有默认的关联值
关联如果是Int，会默认的递增上去；如果不是Int，必须每个枚举值都关联上对应值

// 此处是Float型所以每个枚举值都要关联上对应值
enum Month:Float {
  case January = 18.8
  case February = 13.4
  case March = 19.2
  case April = 17.6
}
//如果明确指出一个变量、变量是属于哪种枚举类型的话，可以直接枚举赋值，否则就  ---- 枚举类型.枚举值
let month = Month.April
let month2:Month = .February
var month1 = Month.March
month1 = .January

switch month{
case .January:
// hashValue指第几个枚举值，rawValue指所对应的关联值
  print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
  print(month)
case .February:
  print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
  print(month)
case .March:
  print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
  print(month)
case .April:
  print("hashValue = \(month.hashValue),rawValue = \(month.rawValue)")
  print(month)
}

七、懒加载
懒加载苹果给予了很形象的一个词： lazy
格式：
lazy var 变量名:变量类型 = {
code...
return
}()

// 以一个button的懒加载为例
  lazy var btn:UIButton = {
    var tempBtn = UIButton(type:UIButtonType.ContactAdd)
    tempBtn.frame = CGRectMake(90, 100, 50, 50)
    tempBtn.backgroundColor = UIColor.cyanColor()
    return tempBtn
  }()

八、函数
函数主要分为四种

// 无参无返
func test()
{
  print("i love swift")
}
test()
//无参有返
func test1()->Int
{
  return 10
}
test1()
// 有参无返
// 当方法有参数的时候 第一个参数名 不显示 要在前面加上
func test2(num1 num1: Int, num2 : Int)
{
  print(num1 + num2)
}
test2(num1: 10, num2: 10)
// 有参有返
func test3(num1: Int, num2: Int) -> Int
{
  return num1 + num2
}
test3(10, num2: 30)

也可以元组作为返回值

// 元组作为返回值
func yuanzu(num1: Int, num2: Int) -> (Int, Int)
{
  return (num1 + num2, num1 * num2)
}
yuanzu(10, num2: 60)

swift中在函数中有个十分牛的地方就是可以实现函数的嵌套 在一个函数内部定义一个新的函数并使用

// 函数的嵌套
func test4()
{
  print("1")
  func test5()
  {
    print("2")
  }
  test5()
}

使用函数嵌套完成简单计算器的实现
要求使外界传入两个数和一个符合 ＋ － ＊ ／ 来进行计算

func jisuanqi(num1: Float, fuhao: Character, num2: Float) -> Float { 
  func add(num1: Float, num2: Float) -> Float
  {
    return num1 + num2
  }
  func sub(num1: Float, num2: Float) -> Float
  {
    return num1 - num2
  }
  func lead(num1: Float, num2: Float) -> Float
  {
    return num1 * num2
  }
  func div(num1: Float, num2: Float) -> Float
  {
    return num1 / num2
  }
  switch fuhao {
  case "+":
    return add(num1, num2: num2)
  case "-":
   return sub(num1, num2: num2)
  case "*":
   return lead(num1, num2: num2)
  case "/":
    return div(num1, num2: num2)
  default:
    return 0
  } 
}

九、闭包
要求实现：定义一个方法（输入参数color，frame，closure（是将刚才的color，frame当做参数，返回一个UIview）），返回一个UIview添加到View上

override func viewDidLoad() {
    super.viewDidLoad()
// 格式：   
/*     闭包：
     {
      (参数名：参数类型) -> 返回值类型 in
      code.....
    }
   
*/
   
let view:UIView = combineView(UIColor.blueColor(), frame: CGRect.init(x: 0, y: 100, width: 375, height: 400)) { (tempColor, tempFrame) -> UIView in
      let view = UIView()
      view.backgroundColor = tempColor
      view.frame = tempFrame
      return view
    }   
 view.addSubview(view) // swift里面不写self，一般只有在闭包内部才会强制要求写self
  }
  
func combineView(color:UIColor,frame:CGRect,closure:(tempColor:UIColor,tempFrame:CGRect)->UIView ) -> UIView{
    // 执行闭包
    let view:UIView = closure(tempColor: color,tempFrame: frame)
    return view
  }