皮卡丘愿你开心.jpg

常量和变量

在Swift中使用 let 修饰一个常量, 使用 var 修饰一个变量;

• let 修饰常量的值是不可以更改的
• var修饰的变量的值是可以更改的;
• 在声明常量和变量的时候可以用表情符号, 中文等命名常量名和变量名.

//输出函数
print("Hello, World!")

// 定义一个常量

// 方法 1:
//定义之后,后面的值只能是字符串,因为指定了常量的类型
let name:String = "詹姆斯"
// 方法 2:
//特性: 隐式类型推断,由初始值来推断常量的类型
let gener = "男"

• 使用let定义的常量的值永远不可以更改

//定义一个变量的方式

// 方式 1:
var age = 100
// 方式 2:

var height : Int = 140` 
- Swift 在定义一个变量或者常量的时候,必须要有确定的类型
`leta :Int= 10
let b : String = "James"
let c : Character = "A" //字符使用双引号,但是只能放单个字符
let d : Bool = false  // false 和 ture```

字符串String

有序的字符的集合 
####//创建一个字符串类型的常量
`let string = "詹姆斯"`

####//创建一个值为空的字符串
`let string1 = ""
let string2 = String();`

####//字符串拼接
`var name = "韦德"
var newName : String = name + “520"`

####//获取字符串的长度
`print(newName.characters.count)
`
####// 运算符重载 当对两个字符串类型做加法操作时, 会自动拼接到一起

```code
let q = "保罗"
let w = "安东尼"
let r = q + w```

####//Swift 不支持隐式类型转化

```code
var age = 100
let e = "Cobain's age is"
let words = e + String(age)```

####//如果想要对两个不一样的数据类型的变量或者常量进行运算,需要使用这样的格式:
```code
// 变量(常量) A +\-\*\/ 目标类型(B)
var width = 100.2
var f = width + Double(height)```

###数组
> ####//定义空数组
`var array3 = [String]()`
####//向数组中追加一个元素
`array1.append(108)`
####//使用运算符重载 向数组中追加一个或多个元素
`array1 += [502]`
####//在数组指定位置插入一个元素
`array1.insert("科比", atIndex: 2)`
####//向数组指定位置插入 一个相同类型的集合数据
`let array5 = ["麦迪", 52]
array1.insertContentsOf(array5, at: 2)`
####//全部删除
`array1.removeAll()`
####//全部删除 但保留内存
array1.removeAll(keepCapacity: true)
####//删除第一个元素
`array1.removeFirst()`
####//从第一个元素开始删除几个
`array1.removeFirst(2)`
####//删除指定位置的元素
`array1.removeAtIndex(2)`
####//删除最后一个元素
`array1.removeLast()`
####//删除range范围的元素(包含起始索引,不包含终止索引)
```code
let range : Range = Range.init(start: 1, end: 4)
array1.removeRange(range)
print("kiki\(array)")```

###字典

>//定义一个字典
```code
var dict = Dictionary<String, Int>()
let dictionary = ["a" : 1, "b" : 2]```
//当key的类型不一样时, key就为 NSObject类型
```code
let dictionary1 = ["a" : 1, 2 : "b"]```
//提前指定key和value的类型 创建一个字典
```code
let dictionary2 : [Int : String] = [1 : "a", 2 : "b"]```
//可以直接通过key值访问字典中的元素print(dictionary2[1])
```code
var dictionary3 = ["詹姆斯" : "韦德", 102 : 522]
dictionary3["韦德"] = "欧文"```
//对一个不存在的key值进行操作, 即 插入一条数据
```code
dictionary3["乐福"] = "love"```
// 让某一个key值为nil 表示删除掉这个key和对应的value
```code
dictionary3[102] = nil
dictionary3.removeValueForKey("詹姆斯")```

###元组

>- //元组是一个可以返回多个值的数据格式
- //在Swift里面声明的时候使用"()"声明
- //元组可以通过下标去访问元素, 也可以通过key值去访问元素
- //整体的数据结构有点类似C语言里面的结构体


>```code
let type = ("东邪", ["西毒", "南帝"], "北丐", "伯通")
print(type)
print(type.0)```
//定义数据类型
```code
let type1 : (String, Int) = ("乔峰", 100)```
//根据key值输出
```code
let type2 : (name : String, age : Int) = type1
print(type2.age)```

--------------
###循环和分支:
---------------
- **// for循环**
```code
forvar i = 0; i < 100; i++ {
    print(i)}for (var i = 0; i < 100; i++){    print(i)
}```

- **// for in 循环遍历**
// 1...10 表示全闭区间 [1,10]
// 1..<10 表示半闭区间 [1,10)
for i in 1...10 {    print(i)
}

```code
let animals = ["猪", "狗", "猫", "鸡"]
for a in animals{    print(a)}
let dict = ["东邪" : "黄药师", "西毒" : "欧阳锋"]
for b in dict {    print(b)}
for (key, value) in dict
 {    print("key : \(key) value : \(value)")
}```
- //while
```code
var number = 0
while number < 10 {    
print(number)   
 number += 1
}```

- // repeat while 即C中的 do...while
```code
var num = 0
repeat {   
 print(num)    num += 1
} 
while num < 10```
--------------
## //分支结构:
----------------
```code
  if 1==0 {   }```

- // String? 在变量的类型后面加 ? , 表示这个变量为可选类型, 可以置为nil
```code
 var string : String? = "James"
if (string != nil) {   }```

- //在Swift里面, 每一个case里面自带一个 break
```code
let age = 23
switch age {
case 1:
    print("age = 1")
    fallthrough  //贯穿 (不会break,而回继续走case 2)
case 2:    
print("age = 2")
case 3:   
 print("age = 3")
case 4:   
 print("age = 4")
default :    
print("age = 5")}```
- //Swift中的switch可以根据区间去获取值

```code
switch age {case 0...10:   
 print("一毛")
case 11...20:    
print("二毛")
case 21...30:   
 print("三毛")
default:    print("四毛")}
var a = 5
switch a
 {
case var value where a < 10 && a > 0:    
          value += 1   
          print(value)
default:    print("Other")}```

- // Swift中的switch可以对一个元组做判断
- // "_"表示忽略元组中这个位置的元素
- // 条件齐全了,就可以不写default
```code
let point = (10, 42)
switch point 
{
case (10, 10):    print("第一象限")
case (_, 10):    print("一,二 象限")
case (10, _):    print("一, 四象限")
case (_, _):    print("谁知道在哪")
}```

-------------
###函数
------------
>无参无返回值
无参有返回值
有参无返回值
有参有返回值
无参有多个返回值
有参有多个返回值
inout函数

- //func + 函数名 (参数列表) -> 返回值类型(无返回值可以以省略 -> Void) {}
```code
func text() -> Void {    print("无参无返回值的函数")
}
text()

• //无参有返回值

func text1() -> String 
{   
 return "无参有返回值"
}
let string = text1()
print(string)```

- //有参无返回值
```code
func text2(name : String, age : Int)
 {    
print("东邪是\(name), \(age)")
}
text2("黄药师", age : 100) ```
 // age : 外部参数名

- //有参有返回值
```code
func text3(name : String, age : Int) -> Array<NSObject> 
{    
let array : Array<NSObject> = [name, age]   
return array
}
let array : [NSObject] = text3("孙悟空", age : 599)
print(array)```

- #####//函数的外部参数名第一个名字表示外部参数名, 当外界使用这个函数的时候使用的名字. 第二个参数表示内部参数名, 当函数里面使用这个参数的时候使用的名字, 外部函数可以用 _ 忽略掉
```code
func text4(number myNumber : Int, name myName : String) 
{    print("名字是\(myName), 编号是\(myNumber)")
}
text4(number: 101, name: "二狗蛋")```
- //无参数有多个返回值的
```code
func text5() -> (String, Int)
 {    return ("张三", 108)
}
let type = text5()
print(type)```

- //有参有多个返回值
```code
func text6(name myName : NSString,age myAge : Int) -> (NSString, Int)
{    return (myName, myAge)
}
let type2 = text6(name: "萌萌", age: 102)
print(type2)```

- //函数嵌套

func text7()
 {   
> func text()
 {        
print("第一层嵌套函数")       
>> func text2() 
{            
print("第二层")            
>>>func text3()
 {
 print("第三层")  
 }  
  >>>> text3() 
 }      
text2()    
}    
text()
}

text7();

- //inout 函数
- // Swift 中的参数 本身上是使用let定义的,即常量, 是不能更改的
- // 如果参数 使用 inout 来修饰, 就成了输入输出参数,在函数内部修改参数,可以影响实参变量的值.
```code
func text8(inout name : String) 
{
    name = "艾弗森"
}
var name = "AI"
text8(&name)
print(name)```

--------
可选类型:
-------
-------
//在swift中, 可选类型 ? 其根源是一个枚举型, 里面有None和Some两种类型.其实所谓的nil就是Optional.None, 非nil就是 Optional.Some
//定义一个可选类型, 表示这个变量可以为nil
`var intNumber : Int? = 100`
//打印  打印出来是个Optional类型的值
`print(intNumber)`
//如果 要取到值 必须对可选类型 强制解包 !
print(intNumber!)
//可选类型分为有值和没值(nil) ,如果可选类型的变量值为nil(没值)时对其 强制解包,程序会崩溃

//如果不确定可选类型是否有值时,用可选绑定, 不需要对可选类型解包
```code
if var intNewNumber = intNumber 
{    
print(intNewNumber)
}else{    
print("error")
}```

--------
结构体
-------
-------

/\* Swift的结构体对比OC来说, 可以添加初始化方法, 可以遵守代理协议等 */
###//使用struct定义一个结构体
###//格式 : struct 结构体名字 { 结构体实现 }

```code
struct Frame {    
//存储属性 : 负责存储值的属性    
var x : Float    
var y : Float    
var width : Float    
var height : Float }```     
######//计算属性 : 负责将存储属性进行运算获得的值的属性    
######//get方法 : 在属性类型后面添加 {} 使用get关键字声明和实现get方法    //set方法 : 同上   
```code
 var centerX : Float
 {       
 set{           
       // set方法 不可以单独实现, 必须搭配着get方法        
      }        
 
 get{           
    //get方法 可以单独实现        
         return x + width/2        
     }    
 }      
 var centerY : Float
 {       
 get{            
      return y + height/2       
      }    
 }   ```
// 结构体属性    
`static var myStruct = "结构体属性, 只能通过结构体调用"    `   
//结构体中可以声明和实现函数    

```code
// 结构体属性
func sayHi() 
{       
    print("函数")
 }   ```    
####//init方法   
```code
// 结构体属性
init(x newX : Float, y newY : Float, width newWidth : Float, height newHeight : Float) {      
  x = newX        
  y = newY        
  width = newWidth        
  height = newWidth    } ```
  //结构体的类方法  
  // 结构体的类方法中只能调用结构体属性  
```code
  static func sayMy() 
{        
    print(self.myStruct)    
}   ```
//属性作用 :
//声明 _实例变量
//声明和实现set方法
//声明和实现get方法
//结构体调用 (调用两个属性 )

    Frame.sayMy()
    print(Frame.myStruct)
//创建一个对象的方式
//方式 1:
```code
var frame1 : Frame = Frame.init(x: 10, y: 10, width: 100, height: 100)```
//方式 2: 自带的构造方法
```code
var frame2 : Frame = Frame(x: 10, y: 10, width: 100, height: 100)```
//对象调用属性
`print(frame1.centerX)`
//对象调用方法
`frame1.sayHi()`