部分基础代码，没完善，还没更新完

//Swift中导入系统类库使用import 类库 名，不在使用<>了，或者不在使用“”了

//Swift中输出语句print

print("Hello, World!")

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

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

let myGender = "女?"

//myGender = "boy";

//定义变量

var carName = "BMW"

carName = "Audi"

print(carName)

//MAK:  - 定义常量，变量：变量类型的隐式转换

//在swift中如果定义常量变量不给定相关的类型，他会隐式转换成String

let name = "Rose";

//如果想这样定义出来一个常量，她会隐士转换成NSString类型

let name1: String = "Black"

//如果给定类型后边赋值的时候需要根据类型进行赋值

let age :Int = 38

//如果定义常量最好给出初始值，定义变量可以不给初始值

var age1 : Int?

//？表示age1的类型为可选类型，其值可以为空

//定义一个字符类型

var char:Character = "A"//赋值字符类型的时候仅需一个字母即可

//定义一个bool类型的变量[在swift中，bool类型的变量只有true类型或者false类型

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

//(变量名)输出相关的内容[插入式取值]

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

var str1 : String = "ajar"

print(str1.characters.count)

//(5).字符串比较

var str3 = "GBLW"

var str2 = "MBBoy"

if str2 == str3 {

print("相等")

}

if str2 != str3 {

print("不等于")

}

//MARK: - 数组

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

//定义一个数组

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

print(nameArray)

var nameArray1 :Array <String> = ["yaqian","little strong","boom sky","FATZhou"];

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

let array = Array<String>()

print(array)

//访问数组中的元素

print(nameArray[1])

//向数组中添加元素

var int_array = Array<Int>()

int_array.append(520)

int_array.append(123)

print(int_array)

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

int_array += [1314]

print(int_array)

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

int_array += [1011,1026]

print(int_array)

//插入元素到具体位置

int_array.insert(521, atIndex: 1)

print(int_array)

//移除某个元素

int_array.removeAtIndex(4)

//移除所有元素

int_array.removeAll()

print(int_array)

//MARK: - 字典

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

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

print(dic)

//定义空字典

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

var dic2 = Dictionary <String,Int>()

print(dic1)

//往字典里添加键值对

dic1["d"] = 50

print(dic)

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

dic["a"] = 90

print(dic)

print(dic["a"])

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

dic.removeValueForKey("b")

print(dic)

//MARK: - 元组tuples

//方法一：直接初始化一个隐式

let tuples = ("蓝鸥一班",["iOS","Html5","Andrdoid"])

print(tuples)

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

let tuplesNew : (String,Array) = ("蓝鸥十四班",["iOS","h5","Unity 3D"])

//取出元组中的值

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

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

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

print(classInfo)

//第二种取值方式：直接通过下标获取元素的值

var classInfor = tuplesNew1.0 + tuplesNew1.1[0] + tuplesNew1.1[1]

//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("i love you")

}while 1 < 0

//使用循环变量数组

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

for animal in animalArray {

print(animalArray)

}

//使用循环遍历字典

var animalDic = ["dog":"fu","pig":"qi"]

for (key,value) in animalDic {

print("key = \(key),value = \(value)")

}

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

//if形式的

let flag1 = true

if flag1 == true {

print("It is true")

}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...100:

print("输出10...100之间的数值")

default:print("other")

}

//特点三：case以后可以使用(let和var修饰的常量或者变量)

switch value {

case var i where value >= 0 && value < 6:

i = 99

print(i)

default:

print("other")

}

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

let point = (10,10)

switch point {

case (10,0):

print("111111")

case (10,8):

print("22222")

case (_,10):

print("44444")

default :

print("33333")

}

//MAEK: - 枚举（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 automn = "秋天"

case winter = "冬天"

}

print(Season.automn.rawValue)

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

print(Direction (rawValue: 2))

//MARK: - 函数

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

//函数的类型有：四种

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

func function1 () ->Void {

print("无参无返")

}

function1();

//2.无返回值，有参数(name就是一个标记)

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

print(str)

}

function2(name: "蓝鸥")

//3.有返回值，无参数

func function3() ->String {

return "boom sky";

}

print(function3())

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

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

return num1 + num2

}

print(function4(5, num2: 6))

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

func function5 (num1 : Int, num2 : Int) ->(Int,Int,Int) {

return (num1 + num2,num1 - num2,num1 * num2)

}

print(function5(10, num2: 2))

//外部参数和内部参数

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

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

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

func fuction6 (first one : Int,second two : Int) {

print((one,two))

}

fuction6(first: 10, second: 3)

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

func function7 (one : Int , _ two:Int) {

print("忽略外部参数")

}

//下划线的作用是忽略外部参数

function7(8, 9)

//函数的嵌套

func test1 () {

func test2 () {

func test3 () {

print("我穿了好多层")

}

test3()

}

print("好有意思啊")

}

test1()

//inout修饰的参数

//func test (inout name:String) {

//    name = "MBBoy"

//    print(name)

//}

//var myName = "yuanyuan"

//test(&myName)

//print(myName)

func admin (var name:String) {

name = "MBBoy"

print("name = \(name)")

}

var myName = "tianxin"

print(myName)

admin(myName)

print(myName)