swift笔记--基础(一)

综述

• swift有四种类型：枚举，结构器,类，函数类型(前两种是值类型，后两个是引用类型)，及一种复合类型元组
• 此学习笔记基于4.0语法

一些小知识

1. Palygtound:从Xcode6开始出现

• 可以快速查看结果，
• 语法特性改变时候可以快速查看。
• 创建工程时候选择Playground工程，即：Xcode初始化启动时候初始化的第一项

2. 一些变化:

• 在Swift中布尔类型与整数类型是完全分离的用Bool 。
• 真用 true 表示；假用 false 表示;这两者都属于Swift中的关键字。
• String 在oc中是类对象，但是在swift中是结构体(性能比较高些)；

3. 注释

   • 一般文档多行注释

   
   		/**
   		- version:
   		- attention:
   		- waring:
   		- important:
   		- author:
   		- throws: 该函数可能会抛出异常
   
   		*/
   		这些特殊的关键词，会在文档里有特殊的颜色标记
   

   • 行注释:苹果官方文档里多用这个

     /// --author:
     

4. 代码分段
   swift使用注释 和MARK来分段

    ```
    // MARK: ----这是一个分段
    ```
   

5. UIKit 简单使用

       let _view : UIView = UIView.init(frame: CGRect.init(x: 0, y: 0, width:100, height: 100))
       _view.backgroundColor = UIColor.red
        self.view.addSubview(_view)
        var tesy = "luo yongmeng"
        for char in tesy.characters {
            print(char)
            print(tesy.characters.count)
        }
   

6. swift中使用定义在另一个文件中的类是不用导入的，swift中没有类导入的概念

7. 多行字符字面量:用（"""）包围起来的部分
   注： 需要注意的是，在多行中的当个换行符是被忽略的

   """
   一个 Swift 程序有一个或多个文件组成。在 Swift 中，文件是一个有意义的个体。能存在于文件顶级目录有如下组件：
   

• 模块导入语句：一个模块是除了文件外最高级的单元。一个模块可以由几个文件组成；一个带模块的文件，对于其它文件而言，是可见的；如果没有 import 语句，一个模块就不能看到另一个模块。例如，如果你想要在 iOS 程序中与 Cocoa 交互，你就需要在文件的第一行，引入 import UIKit。
• 变量声明：文件的最外层声明一个变量，我们称这个变量为全局变量：它将存活在整个程序运行周期中。
• 函数声明：文件的最外层声明一个函数，我们称这个函数为全局函数：所以代码都可见和可访问，不需要发送任何消息给任何对象。
• 对象类型声明：类，struct 或者 enum 的声明。
“”"
```

8. 懒加载

   lazy var names: [String] = {
           print("加载数据")
           return ["12334","88888"]
       }()
   
   

一. 变量和常量

1. 字面量

   • 进制数：2(0b),8(0o),16(0x);其中所有字母必须小写，其次如果字面量可以用"-"分隔(0b0100110_01000)
   • Int:可以通过Int.min和Int.max取出所能表示的最小/最大值，需注意：Int8 等如果直接对其进行初始化的时候必须显式对这些对象做类型声明；
   • Float：默认为Double，如果想声明float显式声明即可；
   • Bool：true和float
   • 高位转地位或者高精度转经度

      let a:Int8 = 120
       print("int8:\(a)")
       let i = Int(a)
       print("转成int：\(i)")
       let testInt = 10003
       let testInt8 = Int8(testInt&127)
       print("高位向地位转换:\(testInt8)")
   
   

2. let 定义常量，var 定义变量，变量如果定义不使用(赋值操作等)会有一个警告：如图
   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjLktxGh-1589445569445)(/Users/vrv2/Desktop/swift/swift1.png)]

   var age : Int = 20;
   age = 30;
   let s : Double = 1213.256
   // s = 4;常量不可以修改
   let tesy = "luo yongmeng"
   let strCount : Int = tesy.characters.count
   var testInt = 0
   var testBool : Bool
   var testDouble : Double
           
   for char in tesy.characters {
        print("the string is \(char) that length with \(strCount)")
        }
   testInt = 5
   testBool = true
   testDouble = 3.14153333
   print("test int \(testInt) test bool \(testBool) test double \(testDouble)  the View is \(_view)")
   
   

注：在实际开发中优先使用变量；可以通过指针拿到对象，从而修改内部属性。

3. 一般不推荐使用关键字作为变量名（标识符），但swift中可以在其前后使用(`)，作为关键字；

   var `var` = 4566
   `var` = 333333
   print("the \(`var`)")
   

4. swift 类型转换
   所有的转换都是显示的转换，即便低精度转高精度：

var testFloat : Float
var reserveDouble : Double
testFloat  = 2.3333333
reserveDouble =  2.3344123412512512
//低精度转高精度
reserveDouble = Double(testFloat)
 //高精度转低精度
testFloat = Float(reserveDouble)

==修改：170913=

二，元组

元组是swift中唯一的复合类型，元组的元素可以是结构体,枚举,基本变量，类，也可以是元组或空元组；元组中必须包含两个元素；

class testClass {
	    var name = "hello world!"
	    
	}
	//        元组 自动推断类型
	        let tupleMu = (10,_view,true,testClass().name)
	//不推荐 该写法 ；
	 //        let tupleMu1 : (Int,UIView,Bool,String) = (10,_view,true,testClass().name)
	//获取元组的元素
	        
	        print("获取元组的元素 get tuple to \(tupleMu) with type :\(type(of: tupleMu))")
	        //通过下标获取
	        print("通过下标获取 get tuple to 1\(tupleMu.1)  2 :\(type(of: tupleMu.3))")
	//      指定 元组标签
	        
	        let tupleMuCl = (isInt:10,isView:_view,isBool:true,myClass:testClass().name)
	         print("指定 元组标签 get tuple to 1:\(tupleMuCl.isInt)  2 :\(tupleMuCl.myClass)")

三, 数组----字典----集合

 func testArrDicSet() {
//        let myArr = [Int]()
//        let myArr = Array()
        let myArr  = [1,3,5,4.5555];
        for temp in 1..<5 {
            print(temp)
        }
        print(myArr)
//        常用函数 myArr.count myArr.isEmpty myArr.contains myArr.insert myArr.remove
        
        let isContain = myArr.contains(5)
        print("iscontain = \(isContain)")
//        var myDic = Dictionary()
//        // 通过字典的不定参数个数的构造方法创建一个字典对象，
//        
//        myDic = Dictionary(dictionaryLiteral: ("1", 1), ("2", 2), ("3", 3))
//        // 使用字典的默认构造方法创建一个空的字典常量。
//        var myDic1 = [Int : Float]()
//        myDic1 = [23:33.3,23:332.444]
//         
//        // 这里也是通过字典的不定参数个数的构造方法创建一个字典常量
//        let myDicC = [Int : Float](dictionaryLiteral: (0, 0.0), (1, 1.1), (2, 2.2))
        var   myDic = ["one":33.3,"three":332.444]
        myDic = ["one":33.3,"two":332.444]
        print("获取字典值:\(String(describing: myDic["two"]))")
    }

四, 范围操作符
一般用在循环里：半开1..<5表示从1到5 但不包含5
全闭区间1...5表示从1到5

```
for temp in 1..<5 {
    print(temp)
 }
for temp in 1...5 {
    print(temp)
 }
```

注：这里不一定是数字或浮点型的，也可以是字符或者字符串

	 func  testRange() -> Int {
        // 表示该范围从"aaa"到"ccc"之间
        let stringRange = "aaa" ... "ccc"
        switch "ccb" {
        case stringRange:
            // 结果输出：In stringRange!
            print("the string is  stringRange numbers!")
        default:
            print("Not in stringRange numbers!")
        }
        return 1
    }
   // 表示该范围从"a"一直到"c"，但不包括"c"
	let charRange = Character("a") ..< Character("c")

四, 转义字符 字符串

1. 转义字符

   含义	字符	含义
   0"	表示空字符（null character）	“\\”
   t”	水平制表符	“\n”
   r”	回车	“\”"
   '”	单引号	“\u{n}”

2. 字符串

• 常用创建方法：

  ```
  	// 创建一个字符串变量empty
  	var emptyS = ""
  	 
  	// 这里用默认字符串构造方法来创建一个空的字符串对象
  	emptyS = String()
  	 
  	// 这里用常用的字符串字面量来初始化一个字符串
  	let strS = "hello world"
  	 
  	// 这里直接通过指定字符序列的字符串构造方法创建一个字符串
  	let strS2 = String("hello world")
  	 
  	// 指定一个字符的字符串构造方法创建一个字符串
  	let ch他 = String(Character("字"))
  ```
  

• 字符串插值
  字符串插值就是在一个字符串字面量中使用\(object)

    	```
    	     var testInt = 0
    	     var testBool : Bool
    	     var testDouble : Double
    	     testInt = 5
    	     testBool = true
    	     testDouble = 3.14153333
    	    
    	     var str:String
    	     str = "testInt -->\(testInt)"+"testDouble -->\(testDouble)testDouble-->\(strCount)"
    	     print("append string is \(str) is contain \(str.contains("\(testBool)"))")	
    
    	```
  

• 字符串格式化

   //字符创格式化
     let name  = 2
     let msg = 45
          
     let time = String.init(format: "%02d:%02d",arguments: [name,msg])
     print("现在是\(time)")
  

五, 控制语句 (大部分在oc中的"()"这里都可以省略)

1. do语句块与c语言使用相同，需注意如果{}不是由do引出那么表示该段为闭包;

2. if的{}不能缺少；

   	 // 1> 判断句不用加（）
       // 2< 判断句结果必须是一个真假值
        if a > 10 {
            print("a 是大于 0 a =\(a)")
            a -= 1
         }else{
             print("a 是小于 0 a =\(a)")
             a -= 2
         }
   
   

3. switch 后面的表达式可以是表示任何类型的表达式，甚至还可以是一个元类，但 case 后面的表达式必须是表示值类型的表达式(case后面可以不用加brack)；

    ```
    	let sex = "男"
    	switch sex {//可以判断字符串,整形，浮点，区间，字符，元组
    	   case "男"://这里可以写多个条件 case 1,3,4或者case 1...3/1..<4
    	      print("是男的")
     //如果需要继续执行下一个case，加上fallthrough
    	//    fallthrough
    	    case "女":
    	      print("是女的")
    	    default:
    	      print("是未知性别")
    	  }
    
    ```
   

4. Swift 3.0版本起，for 循环语句只能使用 for-in 的形式:

       // 这里将输出i = 9到i = 1
   	for i in (1 ..< 10).reversed() {
   		   	print("i = \(i)")
   		}
   				
   let array = [1, 2, 3, 4]
    
   // 获取数组元素以及当前元素对应的索引值
   for (index, elem) in array.enumerated() {
       print("index = \(index), elem = \(elem)")
   }
   
   

5. repeat - while 循环
   与c中的dowhile循环类似，只是因为do作为do语句块的引入词，所以加入repeat代替：

    ```
    repeat{
    }
    while condition
    //示例
    repeat{
        if a > 10 {
            print("a 是大于 0 a =\(a)")
            a -= 1
        }else{
            print("a 是小于 0 a =\(a)")
            a -= 2
        }
    }
    while a > 0
    ```
   

6. 提前退出 guard ，类似于断言，一般用在###函数里###，确保后面的bool值为真,但是语句后面必须得有else语句：

   var number = 10
   //如果这里为 false 程序就不会继续执行下去
   guard number < 100 else {
       // 这里使用exit()函数退出
       exit(0)
   }
   //示例
     func testGuard(age : Int ) -> Bool {
       guard age >= 20 else {
           print("错误 信息 重新开始")
           return false
       }
       print("信息正确 继续执行 ")
       return true
   }
   
    /// guard 示例
    let _ = self.testGuard(age: 30)