综述

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

一些小知识

Palygtound:从Xcode6开始出现
- 可以快速查看结果，
- 语法特性改变时候可以快速查看。
- 创建工程时候选择Playground工程，即：Xcode初始化启动时候初始化的第一项
一些变化:
- 在Swift中布尔类型与整数类型是完全分离的用Bool 。
- 真用 true 表示；假用 false 表示;这两者都属于Swift中的关键字。
- String 在oc中是类对象，但是在swift中是结构体(性能比较高些)；

注释

一般文档多行注释


        /**
        - version:
        - attention:
        - waring:
        - important:
        - author:
        - throws: 该函数可能会抛出异常

        */
        这些特殊的关键词，会在文档里有特殊的颜色标记

行注释:苹果官方文档里多用这个
```
/// --author:
```

代码分段
swift使用注释和MARK来分段
```
```
// MARK: ----这是一个分段
```
```

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)
     }

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

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

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

懒加载

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

一. 变量和常量

字面量
- 进制数：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)")
```

let 定义常量，var 定义变量，变量如果定义不使用(赋值操作等)会有一个警告：如图
变量定义不适用警告

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)")

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

一般不推荐使用关键字作为变量名（标识符），但swift中可以在其前后使用(`)，作为关键字；
```
var `var` = 4566
`var` = 333333
print("the \(`var`)")
```

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<Int>()
        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<String, Int>()
//        // 通过字典的不定参数个数的构造方法创建一个字典对象，
//        
//        myDic = Dictionary<String, Int>(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")

四, 转义字符字符串

转义字符

字符	含义	字符	含义
“\0”	表示空字符（null character）	“\\”	表示反斜杠
“\t”	水平制表符	“\n”	换行
“\r”	回车	“\”“	双引号
“\’”	单引号	“\u{n}”	Unicode标量值的转义语

字符串

常用创建方法：

    // 创建一个字符串变量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中的”()”这里都可以省略)

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

if的{}不能缺少；

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

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("是未知性别")
      }

```

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)")
}

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
```

提前退出 ==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)

swift笔记--基础(一)

综述

一些小知识

一. 变量和常量

二，元组

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

四, 转义字符字符串

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

猜你喜欢

swift笔记--基础(一)

综述

一些小知识

一. 变量和常量

二，元组

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

四, 转义字符 字符串

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

猜你喜欢

四, 转义字符字符串