Swift

一、Swift简介

2010年的夏天，苹果公司的开发人员 Chris Lattne 接到了一个特别的任务，为OSX何iOS平台开发下一代的编程语言，也就是Swift。

苹果公司于2014年WWDC(苹果开发者大会)发布的新开发语言Swift，可与Objective-C共同运行于Mac OS和iOS平台，用于搭建基于苹果平台的应用程序。

2015年的WWDC开发者大会上，苹果公司推出了Swift2.0版本，并且Swift完全开源。

自从Swift发布以来，在http：//www.tiobe.com中的排行一直处于上升的状态。

在Swift中使用"let"修饰一个常量，使用var修饰一个变量

let修饰常量的值是不可以更改的；
var修饰的变量的值是可以更改的；

在声明常量和变量的时候可以使用表情符号、中文等命名常量名和变量名。

Swift定义变量或者常量的时候，需要标识出变量或者常量的类型，如果不标识，会根据初始值自动推断，
如：
//会自动推断变量a为Int类型
var a = 10
//会自动推断常量b为String类型
let b = "Hello"

Int、 Float、Double、String、Charater(字符使用双引号，但是里面只能放单个字符)；

例如：
let a:int = 10
let b:Srting = "Hello"
let c:Character = "A"
let flag:Bool = false
注意：值永远不会被隐式转换为其他类型：如果你需要把一个值转换成其他类型，请限式转换

let name ="Lanou's age is''
let age = 3

let words = name +String(age)

字符串

1、String是有序的字符集合，例如"Hello 蓝鸥"
2、Swift中的字符串通过String类型表示，当然也可以看成Character字符类型的集合

(1).//定义字符串变量

var var_str = "Hello 蓝鸥"

(2).//创建空String变量

//这两个字符串都为空，并且两者等价

var empty_str1 = ""
var empty_str2 = String()
(3).//通过字符串对象的isEmpty方法判断是否为空

if empty_str1.isEmpty {
print ("'empty_str1 is empty
")
}
(4).//字符串连接
//创建字符串变量

var var_str = "http://"
//字符串拼接后，var_str = "http：//www。lanou3g.cm"

var_str += "www.lanou3g.com"
注意：let con_str = "hello"常量不能被修改！！

(5).//创建字符串常量

let con_str = "Hello"
//获取字符串的长度

let length = con_str.characters.count

(6).//字符串插值
let mul = 3.0

let content = "\(mul)x2.5 = \(mul*2.5)"

(7.)//字符串比较

let name1 = "xiaohao"

let name2 = "lanou3g"

if name1 == name2
print("\(name1)equals\(name2)")

else {
print("not equal")
}

 

//Swift中导入系统库使用import，不再使用<>了，(或者不在使用""了)
import Foundation


//Swift中输出语句：print
print("Hello, World!")

//MARK:- 定义常量.变量

//定义常量 (使用完第一次就不能修改它的值了)

let myGender = "男"

//定义变量
var carName = "BMW"

carName = "Audi"

print(carName)

//MARK: - 定义常量变量:变量类型的隐式转换

//在Swift中如果定义常量变量不给定现骨干那的类型，它会隐式转换成你给定的初始化值类型
let name = "Jet"//如果这样子定义出来一个常量，它会隐式转换成String类型

let name1 : String = "Yue"  //如果给定类型，后边赋值的时候需要根据类型进行赋值


let age : Int = 18 //如果定义常量最好给出初始值，定义常量可以不给初始值

var age1 : Int? //?表示age1的类型为可选类型，其值可以为空

print(age1)

//定义一个字符类型的变量

var flag :Bool = true;

//MARK： - 字符串string

//(1)创建一个空的字符串


var str_empty = ""
var str1_empty = String()




//(2)判断一个字符串为空字符串

if str_empty.isEmpty {
    print("str_empty is empty");
}

//(3)字符串的拼接

var str_url = "http://"

var str = "www.baidu.com"


let str_new_url = str_url + str


print(str_new_url)


print("百度网址:/(str_new_url)")// \(变量名)输出相关的内容[插入式取值]



// (4)获取字符串的长度

var str1 : String = "abcdef"


print(str1.characters.count)


//(5)字符串的比较

var str2 = "MBBoy"

var str3 = "GBLW"

if str2 != str3 {
    //==
    print("两个字符串不相等")
}


//MARK: - 数组

//Swift中数组中的元素类型必须相同

//定义一个数组


var nameArray = ["yuanyuan","GBLW","WYW"]

print(nameArray)


var nameArray1 : Array<String> = ["YaQian","XiaoQiang","FatZhou"]


//定义一个空数组 (字符串)


let array = Array<String>()

print(array)

//访问数组中的元素

var int_aray = Array<Int>()

int_aray.append(520)

int_aray.append(234)

print(int_aray)

//使用运算符添加数组元素

int_aray += [100]

int_aray += [120]

print(int_aray)

//使用运算符添加多个数组元素


int_aray += [800,900,1000]

print(int_aray)


//插入元素具体的位置

int_aray.insert(521, atIndex: 1)


//移除某个元素

int_aray.removeAtIndex(4)
print(int_aray)


//移除所有元素

int_aray.removeAll()

print(int_aray)

//MARK: - 字典


//定义一个字典类型的变量

var dic : Dictionary<String,Int> = ["a":18,"b":69,"c":38]

print(dic)
//定义空子典

var dic2 : Dictionary<String,Int>  = [:]
var dic1 =  Dictionary<String,Int> ()

//往字典中添加键值对

dic["d"]  = 10

print(dic)


//修改字典中的内容 （根据键去修改值）



dic["a"] = 20


print(dic)


print(dic["a"])

//删除字典中的内容（根据键去删除）


dic.removeValueForKey("b")


print(dic)


//MARK: - 元组



//方法一：直接初始化一个元素（使用swift隐式转换的特点）

let tuples = ("蓝鸥1班",["iOS","HTML5","Android"])

print(tuples)


//方式2：显示初始化的方式

let tuplesNew :(String,Array) = ("蓝鸥8班",["iOS","HTML5","Android"])


//取出元组中的值

//地址-中取值方式：直接把元组赋值给另外一个常量，根据相关标记进行取值


let tuplesNew1 : (classroom:String,course:Array) = tuplesNew


let classInfo = tuplesNew1.classroom + tuplesNew1.course[0] + tuplesNew1.course[1] + tuplesNew1.course[2]


print(classInfo)

//第二种方式直接根据下标取值

var classInfoNew = tuplesNew1.0 + tuplesNew1.1[0] + tuplesNew1.1[1] + tuplesNew1.1[2]
print(classInfoNew)


//MARK: - 循环

//第一种形式

for var i = 1; i < 10; i++ {
    print(i)
}
//第二种形式
for number in 1..<10 {
    print(number)
}

//第三种形式

for number in 1...10 {
    print(number)
}

//while循环和repeat...while


var i = 8

while i < 0 {
    i--
    print(i)
}



repeat { //先执行一次循环体，再进行相关的循环
print("爱你们")

}while i<0


//使用循环遍历数组

var animalArray = ["dog","pig","cat","tiger"]

for animal in animalArray {
    print(animal)
}
//使用循环遍历字典

var animalDic = ["dog":"🐶","pig":"🐷"]


for (key,value) in animalDic {
    print("key = \(key),value = \(value)")
}

//MARK: - 分支结构 (if结构和switch格式)


//if形式的
let flag1 = true

if flag == true {
    print("我是真的真的爱你")
}else {
    print("你们...")
}

//switch形式使用fallthrough实现贯穿每种可能

let value = 0

switch value {
case 0:
    print("0")
    fallthrough
case 10:
    print("10")
    
    fallthrough
    
default:
    print("other")
    
}

//特点二：case后可以使用一个范围


switch value {
case 0..<10:
    print("输出0-10之间的数值")
case 10...1000:
    print("输出10...1000的数值")
default:
    print("other")
}

//特点3：case 后可以使用（let var 修饰的常量或者变量）

switch value {
case var i where value >= 0 && value < 6:
    i = 99
    print(i)
default:
    print("other")
}

//特点4：case后还可以匹配一个元组

let point = (10,10)


switch point {
case (10,0):
    print("11111")
    
case(10,8):
    print("22222")
    
case(_,10)://_代表忽略某个元素
    
    print("33333")
default:
    print("other")
    
}

//Mark: - 枚举(enum)

//枚举原始类型为int类型的

enum Direction:Int {
    
    case east = 0
    case south = 1
    case west = 2
    case north = 3
    
    
}

print(Direction.east.rawValue) //rawValue 就是找到相对应枚举的原始值

//枚举原始类型为String类型的


enum Season :String {
    case spring = "春天"
    case summer  = "夏天"
    
    case autumn = "秋天"
    
    case winter = "冬天"
}


print(Season.autumn.rawValue)


//根据原始值获取枚举的类型

print(Direction(rawValue: 2))


//MARK: - 函数

//表示函数的关键字：func

//函数的类型有：四种

//1.无返回值，无参数

func function1() ->Void {
    print("无返回值，无参数的")
}

function1()


//2:无返回值，有参数

func function2(name str:String) ->Void {
    print(str)
}


function2(name: "lanou")

//有返回值，无参数

func function3 () ->String {
    return "炸天"
}


print(function3())


//4.有返回值，有参数

func function4(num1:Int,num2:Int) ->Int {
    return num1 + num2
}


print(function4(5, num2: 6))


//函数的返回值为元组类型的

func function5(num1:Int,num2:Int) ->(Int,Int,Int) {
    return(num1 + num2 ,num1 - num2 , num1 * num2)
}



print(function5(9, num2: 2))



//外部参数和内部参数


//first,second 就叫做外部函数:在函数调用的时候，会显示出来这两个名称


//one、two内部参数：在函数内部使用的

//默认的情况下，第一外部参数在调用的时候不显示，其余的均显示，而且和你定义的名字一样

func function6(first one:Int,second two:Int) {
    print((one,two))
}



function6(first: 10, second: 2)


//如果都不想显示外部参数


//“—”的作用是忽略外部参数名

func function7(one:Int,_ two:Int) {
    print("忽略外部参数")
}


function7(8, 9)




//函数的嵌套

func test () {
    func test2 () {
        func test3 () {
            print("哈哈，我穿了好多衣服")
        }
        test3()
    }
    test2()
    print("😄,好有意思啊")
}
test()


//inout修饰的参数

/*
func test(inout name:String) {
    
    name = "MBBoy"
    
    
}

var myName = "yuanyuan"

print("myName:\(myName)")

test(&myName)


print(myName)


*/


func admin (var name:String) {
    name = "MBBoy"
    
    print("nameOld = \(name)")
}

var myName = "tianxin"

admin(myName)

print("myName = \(myName)")