Swift

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