ios-swift基础

在swift中用let来定义常量，是不能修改的，var定义的是变量是可以修改的

在swift中我们最好尽量的去使用let，如果你必须要修改这个变量的时候再去用var，这样程序会更安全

在swift中会根据设置数值的的代码，来确定常量或变量的类型

整数的默认类型是Int Int默认是64位的长整型

小数的默认类似是Double 精度更高

我们可以在定义变量的时候就去声明变量的类型比如说

let app:Double=10

在swift中，任何时候都不会去做隐式的转换，任何两个类型不同的变量或者是常量都不允许直接进行计算，比如说

        let a1=10
        
        let b1=1.5
        
        let c1=a1+b1

这样是会报错的，因为b1是double类型，而a1是int类型，我们在相加的时候就要去做强制类型的转换，

如果在构造方法中会出现? 表示不一定能创建出对象

如果参数中没有?那么就表示必须要有值，如果为nil，就会崩溃

!表示强行解包，也就是比如说 y! 就表示y肯定是有值的，如果没有值那么程序就会崩溃

会出现 unexpectedly found nil while unwrapping an Optional value 这个错误

有一点是需要注意的是为什么常量无法修改其实是指的是指针地址不能修改了，但是修改属性还是可以的，就比如说这样

      // 视图实例化之后，并没有修改指针地址
        let view = UIView(frame: CGRect(x: 10, y: 10, width: 100, height: 100))
        // 只是在修改了属性
        view.backgroundColor = UIColor.red

在switch中case的后面是不需要break的，而且在OC中switch()中只能是int类型，而在Swift中可以是任何类型

以及我们在case中声明变量的时候可以不需要用{}来进行分隔作用域，在switch中每一个case必须至少包含一个语句

 let number="111"
        switch number
        {
           case "1":
            let name = "kkk"
            print(name)
           case "2":
            print("k")
           case "3": break
           default:
            print("jj")
            
        }

var的可选项默认的值是nil，也就是说var name: String?的默认值是nil，如果是let name: String?是没有默认值的，我们必须要去设置初始值

如果我们在定义常量的时候，如果只指定了类型，没有设置初始值，我们就可以有一次去设置初始值的机会，但如果没有指定类型，比如说let a这样是会报错的

？？操作符号，可以判断之前的变量是不是为nil，如果为nil，就可以使用后面的来进行替换，比如说

var Klll: String?
print((Klll ?? "")+"哈哈")

这里需要注意的是如果我们Klll这里不加()如下的情形

 var Klll: String?
  Klll="jjjjj"
 print(Klll ?? ""+"哈哈")

只会输出 jjjjj 因为??的优先级低，+先运算，然后再运算??，最后Klll的值替换了后面的值

字符串在swift中是String类型

属于结构体，支持直接遍历，量级轻

下面可以遍历这个字符串

 let string="回家"
 
 for c in string.characters
{
  print(c)
}

输出字符的长度

      let string="回家"
      //输出字节数一个中文的UTF编码对应3个字节
      print("\(string.lengthOfBytes(using: String.Encoding.utf8))")
      
     //返回字符串中字符的数量
      print(string.characters.count)
     //字符串拼接
      print("\(string)") 
     //格式化输出字符
        let a=10
        let b=8
        let c=6
        let dateString=String(format: "%02d:%02d:%02d", a,b,c)
        print(dateString)
      //也可以这么使用
      let dateString1=String(format:"%02d:%02d:%02d", arguments: [a,b,c])
        print(dateString1)

在OC中是NSString类型，继承自NSObject的对象类

在字符串中如何去取子串

//根据这个范围去截取子串，string as NSString其实就是把string转换成NSString的类型
 let string ="kkkkllll"
 let str=(string as NSString).substring(with: NSMakeRange(0, 3))
 //也可以通过这样去截取，开始的index往后偏移四个位置
   let startIndex = string.index(string.startIndex,offsetBy: 4)
   let endIndex=string.endIndex
   let range=startIndex..<endIndex
   let str1=string.substring(with: range)

在数组中我们如果需要存放数字就不需要包装成NSNumber，如果要存放结构体的话，我们就需要用NSValue来进行包装

如果我们在定义数组的时候，自动推导的类型是[String]类型，这就决定了数组中只能存放String，我们可以定义一个指定类型的数组，就可以存放任意对象了

var array :[AnyObject] = ["hhh"]

在swift中有一个叫做AnyObject 表示任意对象，而在OC中所有的对象都是继承自NSObject，swift中的对象是可以没有任何的父类的

我们如果就定义了一个数组，而不去为它分配空间的话，我们是无法往里面去插入东西的，所以我们定义完成之后要初始化，比如说这样子

var array:[String]
array = [String]()

在swift的字典中，我们声明了一个字典var dict ["name":"哈哈"] 如果我们直接通过dict["name"]="kk"这样如果key相同是会直接覆盖的，如果key不相同则会新增。

合并两个字典，其中k和v是我们可以随便定义的名字

var dict=["name":"哈哈"]
        let dict2=["title":"kkk"]
        
        for (k,v) in dict2
        {
            dict[k]=v
        }

关于数组的合并，我们要保证数组的类型要保持一致，所以可以这么做，其中array2就是NSObject类型

var array: [NSObject] = ["哈哈" as NSObject,"看看" as NSObject]

let array1 :[NSObject] = ["王五" as NSObject,"快快快" as NSObject]

let array2 = ["kk" as NSObject,NSNumber(integerLiteral: 18)]
        
        array+=array1
        
        array+=array2
        

在swift中定义一个函数我们可以用func 函数名(形参列表) -> 返回值类型，如下所示，

 func sum(x:Int,y:Int) -> Int
    {
        return x+y
    }

在Swift中还有外部参数的讲究，外部参数的作用就是方便调用该函数的程序员，更加的明确各个参数的语义

func sum(num1 x:Int,num2 y:Int) -> Int
    {
        return x+y
    }

没有返回值的情况，我们可以定义函数可以这么定义

1、什么都不写

2、写返回参数为Void

3、写()

    func Test1()
    {
        print("1")
    }
    func Test2() -> Void
    {
     print("2")
    }
    func Test3() -> ()
    {
    print("3")
    }

定义闭包

1、闭包的所有代码[参数 返回值 执行代码] 都可以放到{ }中

2、in 是用来区分函数定义和执行代码的

格式是{ (外部参数 形参列表) -> 返回值 in //代码执行}

   let sumfunc = {
        
        ( x: Int,  y: Int) -> Int
        in
        return x + y
    
    }

一个简单的闭包，如果没有参数和返回值，参数/返回值/in 全都可以省略，类型是() -> ()

 let sumfunc = {
       print("lll")
    }

在Swift中不允许用下标去直接访问可选数组，所以我们需要先强行的解包。

 cell.person = persons![indexPath.row]