兼容Swift 早期版本 swift语言最新版本

//MARK: - 定义常量变量
//定义常量(使用完一次之后就不能修改它的值了)
//Swift中输出语句print
print("Hello, World!")
/*
let myGender = "男"

//定义变量
var carName = "BMW"
carName = "BYD"
print(carName)

//MARK - 定义常量变量;变量类型的隐士转换
let name = "Jack"
//如果这样子定义一个常量,他会隐士转化为string类型
//在swift中定义常量变量不给定确切的类型,隐士转化为初始值类型

let name1 : String = "Rose";//如果给定类型,后边赋值的时候需要根据类型赋值

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

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

print(age1)

//定义一个字符类型的变量
var char : Character = "A"//赋值字符类型的时候仅需一个字母即可
//定义一个bool类型d的变量 [在swift中bool类型的变量只有true或者false]
var flag : Bool = true
var flag1: Bool = false

//=======================
//=======================

//MARK: - 字符串string
//(1)创建一个空的字符串
var str_emperty = ""
var str1_emperty = String()
//(2)判断字符串为空
if str_emperty.isEmpty{
    print("str_emperty is empty")
}

//(3)拼接字符串
var str_url = "http://"
var str_urll = "www.baidu.com"
let str_NewUrl = str_url + str_urll
print(str_NewUrl)
print("百度网址:\(str_NewUrl)\n") // \(变量名)输出相关的内容[插入式取值]

//(4)获取字符串的长度
var str1 : String = "abcd"
print(str1.characters.count)


//(5)字符串的比较
var str2 = "aaa"
var str3 = "bbb"
if str2 != str3{
    print("两个字符串不相等")
}

//======================
//======================
//MARK: - 数组
//swift中的数组元素类型必须相同
//定义数组
var nameArray = ["yuanyuan","GBLW","WYW"]
print(nameArray)

var nameArray1 : Array<String> = ["YQ","XQ","FatZhou"]

//定义一个空数组(字符串)
var 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 += [100]
int_array += [120]
print(int_array)
//使用运算符添加多个元素
int_array += [200,221,331]
print(int_array)

//插入元素到具体的位置

int_array.insert(521, atIndex: 1)
print(int_array)

//移除某个元素
int_array.removeAtIndex(4)
print(int_array)

//移除所有的元素
int_array.removeAll()
print(int_array)

//==========================
//==========================
//MARK: - 字典
//定义一个字典类型的变量
var dic : Dictionary<String,Int> = ["a":15,"b":69,"c":34]
print(dic)

//定义空字典
var dic1 : Dictionary<String,Int> = [:]
var dic2 = Dictionary<String,Int>()

//向字典中插入键值对
dic["d"] = 50
print(dic)

//修改字典中的内容(根据键去修改值)
dic["a"] = 90
print(dic["a"])
//删除字典中的内容(根据键去删除)
dic.removeValueForKey("b")
print(dic)

//MARK: - 元组
//定义一个元组
//方法一:直接初始化
let tuples = ("蓝鸥1班",["ios","html5","Android"])
//方法二:显示初始化的方式
let tuplesNew : (String,Array) = ("蓝鸥8班",["ios","html5","Android"])
//取出元组中的值
//第一种方式;直接把元素赋值给另外一个常量,根据相关的标记进行取值
let tuplesNew1: (classroom:String,course:Array) = tuplesNew
var classInfo = tuplesNew1.classroom + tuplesNew1.course[0] + tuplesNew1.course[1] + tuplesNew1.course[2]
print(classInfo)

//第二种方式:直接根据下标取值
var classInfoNew = tuplesNew.0 + tuplesNew.1[0] + tuplesNew.1[1] + tuplesNew.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 1 < 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 flagl = true
if flagl == true {
    print("艾克")
}else{
    print("马克")
}

//switch形式使用fallthrough实现贯穿每种可能
let value = 0
switch value{
case 0:
    print("0")
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修饰的常量或者变量)where是满足某种条件
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("1111")
case (10,18):
    print("2222")
case (_,10):      //_代表可以忽略某个元素
    print("3333")
case (10,10):
    print("4444")
default:
    print("other")
}
//MARK - 枚举(enum)
//枚举原始类型为int类型的
enum Direction:Int
{
    case east = 0
    case sout = 1
    case west = 2
    case north = 3
}
print(Direction.east.rawValue)//就是找到相对应枚举的原始值

//枚举原始类型为string类型的
enum Season:String
{
   case spring = "春天"
   case summer = "夏天"
   case autumn = "秋天"
   case winnter = "冬天"
}
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: "蓝鸥")
//3.有返回值,无参数
func function3() ->String{
    return "炸天"
}
print(function3());
//有返回值,有参数

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 tow  内部参数:在函数内部使用的
//默认的情况下,第一个外部参数在调用的时候不显示,其余均显示
func function6(first one:Int,second tow:Int){
    print((one,tow))
}
function6(first: 10, second: 3)

//如果都不想显示外部参数
func function7(one:Int,_ two:Int){
    print("忽略外部参数")
}
function7(8, 9)

//函数嵌套
func test1(){
    func test2(){
        func test3(){
            print("哈哈哈")
        }
        test3()
    }
    test2()
    print("啊啊啊啊")
}

test1()
//inout修饰的参数
func test(inout name:String){
    name = "zhang"
    print(name)
}

var myName = "yuanyuan"
test(&myName)
print(myName)
*/
func admin(var name:String){
    name = "lili"
    print("nameOld = \(name)")
}
var myName = "gaga"
print("myName = \(myName)")

admin(myName)
print("myName = \(myName)")