皮卡丘愿你开心.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()
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
{
let array : Array = [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()`