Swift

let修饰常量、var修改变量

常量的本质：保存的内存地址不能被修改(但是可通过内存地址拿到 对应的对象，修改对象的内部属性)

基本运算:相同类型才可以运算

Int:相当于NSInteger
Float,Double
let m = 20;
let n = 20.1;

如上计算的时候swfit是保存的 因为swift不会自动将m转换成double，所以呢 我们需要转换 即：Double(m)，OC:(Double)m

guard:逻辑分支

funciton xxx (){
guard 判断句 else {
不满足条件要操作的内容
return/break/continue
}
满足条件的语句
}

switch

swift 中可以判断多个条件(0，1),double、字符串、区间判断

let m=30;
let n =20;
let opration = "+"
switch opration {
case "+":
result = m+n
case "-":
result = m-n
case "":
result = mn
case "/":
result = m/n
default:
print("操作符")
}

区间操作

1.开区间
0..<10 表示0~9 不包含10
2.闭区间
0...10 表示0~10 包含10

let score = 80;
switch score {
case 0..<60:
print("不及格")
case 60..<80:
print("及格")
case 80..<90:
print("良好")
case 90...100:
print("优秀")
default：
print("不合理的分数")
}

for循环

for i in 0..<10{ // i 代表下标
print(i)
}
另外一种写法
for _ in 0..<10{ //swift中如果一个标识符不需要，可以使用_来代替
}

字符串

oc与swift中字符串的区别

• 在OC中字符串类型是NSString 在Swift中是string
  • 字典 NSSDictionary -> Dictionary ,NSArray -> Array
• OC中字符串@"",Swift中字符串""
• string(结构体)支持直接遍历。swift 提供了String 和 NSSting之间的无缝转换

定义字符串
let str = "Hello Word"
//遍历
for c in str.characters{
}
//字符串拼接
OC

• [NSString StringWithFormat@"@%@%",str,str]
  swift
  let str = "小妈哥"+"ios教育"
  字符串和其它标识符之间的拼接
  let name = "MiYaLiuNian" let age=18 let height=1.88
  let info = "my name is \ (name) ,my age is \ (age) , my height is \ (height)"
  String(format:"%02d:%02d",arguemts:[2,8])
  字符串截取
  let urlString ="www.520it.com"
  //将string转换成NSString类型 string as NSString
  let header = (urlString as NSString).substringFromIndex(3)
  let middle = (urlString as NSString).substringWithRange(NSMake Range(4,5))
  let footer = (urlString as NSString).substringFromIndex(10)

数组

• 数组(Array)是一串有序的由相同类型元素构型的集合
• 数组中的集合元素是有序的，可以重复出现
  定义数组
• let 修饰的就是不可变数组
  let arr: Array = ["一","二","三","四"]
• var 修饰的就是可变数组

• var arrM =Array<String>(), 但是开发中经常这么写:var arrM = [String]

对于可变数组的基本操作

• 添加元素
  arrM.append("wsj")
  arrM.append("sdfsd")
  arrM.append("wef")
• 删除元素
  arrM.removeAtIndex(0)
• 修改元素
  arrM[1]= "dddd"
• 取出某一个元素
  arrM[1]
  数组的遍历
• 根据下标值进行遍历
  for I in 0..< arrM.count{
  }
• 直接遍历数组中的元素
  for name in array{
  }
• 遍历数组中的前两个
  for name in arry[0..<2]{
  }
• 数组合并
  let newArr= arrM+arry
  注意：相同类型的数组才能合并，不同类型数组不能合并

字典

字段允许按照某个键来访问元素
字典是由2部分集合构成的，一个是键(key)集合，一个是值(value)集合
键集合是不能重复的，值集合可以重复
定义字典

• 不可变字典
• let dic = ["name":"zhangsan","age":"18",height:"1.89"] 系统会自动判断后边的[]存放的是键值对，还是一个个元素
• 可变字典
  AnyObject 一般用于指定类型，NSObject 一般用于创建对象
  var dicM = [ String:AnyObject ] () 开发时一般都是这么写
  对可变字典的基本操作
• 添加元素
  dicM["name"] = "张三"
  dicM["age"] = 18
  dicM["height"] = 1.89
  dicM["weight"] = 70
  dicM["weight"] = 70
  删除元素
  dicM.removeValueForKey("name")
  修改元素
  区别：如果字典中已经有了对应的key,那么会直接修改原来的key中保存的value
  dicM["name"] = "李四"
  遍历字典
• for key in dictM.keys{} //遍历所有的key
• for key in dictM.values{} //遍历所有的value
• for (key,value) in dictM.values{} //遍历所有的键值对
  合并字典
• ~~ 即使类型一致也不能相加合并~~

元组

• 一般用于方法返回值
• 元组是数据结构，在数学中应用广泛 类似于数组或字典 可以用于定义一组数组 组成元组类型的数据可以称为元素
• let info = ("name",18,"height",1.89)
  取值 ：元组标识符.下标 info.0 info.1 info.2
  可以给元组每一个元素起别名
• let info = (name:"zhangsan",age:18,height:1.89) 起了别名之后取值可以 info.name

可选类型

• 在OC开发中，如果一个变量暂时不使用，可以赋值为0(基本属性类型)或者赋值为空(对象类型)
• 在swif开发中，nil也是一个特殊的类型，因为和真实的类型不匹配是不能赋值的(swift)是强类型语言

定义可选类型 语法糖(常用)
var name :String ? = nil

• 给可选类型赋值
  name = "why"
• 取出可选类型的值
  name!
• 强制解包是非常危险的操作，如果可选类型为nil，强制解包系统会崩溃
  建议在解包钱，先对可选类型进行判断，判断是否为nil
  if(name != nil){
  print(name)
  }
• 可选绑定
• 1 判断name是否有值
• 2 name不为空的时候，系统会自动将name进行解包，并且将解包后的结果，赋值给tempName
  if let tempName = name { //不常用
  print(tempName)
  }
• 可选类型应用场景
• • 通过一个字符串创建一个url 对象并且创建URLRequest对象
    let url : NSUrl ? = NSUrl(string:"http://www.520it.com")
    if let url = url {
    let request = NSURLRequest(URL:url)
    }

函数

• 函数的格式

 func  函数名(参数列表) -> 返回值类型 {
     代码块
    return 返回值
    }

//1.没有参数没有返回值
func about() -> Void {
   print("Iphone7")
    }
//2.没有参数有返回值
func readMessage() -> String{
      return "吃饭了吗"
    }
// 3.有参数没有返回值的函数
func callPhone(phoneNum:String) {
    print("打电话"+phoneNum)
  }
//有参数有返回值的函数
func sum(num1: Int ,num2:Int) -> Int{
    return  num1 +  num2
  }



//默认参数
func makeCoffee(coffName: String = '雀巢') -> String {
    return "制作了一杯\(coffName)咖啡"
  }

//可变参数
func sum(num:Int ...){
  var result = 0 
   for n in num{
       result += n
     }
return result
}

类定义

class  类名 ： SuperClass{
  定义属性和方法
}
~~ 定义的类，可以没有父类，那么该类是rootClass ~~
Class Person {
   //存储属性
   var age : Int = 0
   var name: String ?
   var mathScore : Double = 0.0 
   var chineseScore : Double = 0.0
  //计算属性
  var averageScore : Double {
    return (mathScore + chineseScore ) *0.5
      }
  //定义类属性：类属性是和整个类相关的属性，而且是通过类名进行访问
  static var courseCount : Int  = 0 
  }

let p = Person()
p.age = 20

//访问类属性
Person.courseCount = 2

类的构造函数

Class Person : NSObject {
      var name : String ?
      var age : Int = 0
        //子类重写父类方法时 一定要使用关键字 override
      override init(){
      //在构造函数中，如果没有明确调用super.init() ,那么系统会帮助调用
    }
      //自定义构造函数
    init(name : String , age : Int){
      self.name = name  // 加上self.是为了区分, 哪个是对象本身属性、哪个是构造函数传进来的值
      self.age =age
    }
     // 
    init(dict:[String : AnyObject]) {
      //取出的值：可选类型
      将AnyObject ? 转换成 String ?
     as? 转换成可选类型
     as! 转换成确定类型
      name = dic["name"] as? String
      age = dic["age"] as! Int
   }
}

监听类的属性改变

Class Person :NSObject {
      //属性监听器
   var name : String ?  {
      //属性即将改变时进行监听
         willSet{
            //永远显示oldValue
                }
      //属性已经改变时进行监听
        didSet{
            //永远显示newValue
              }
    }

}

闭包

• 闭包和OC中的block非常相识
• Swift中的闭包是一个特殊的函数
• block 和 闭包 都是经常用于回调

闭包的使用

oc block回顾
 - (void) touchesBegan:(NSSet<UITouch *> *) touches withEvent:(UIEvent *) event{

  }