/*
let 定义常量,var 定义变量
*/
var hello = "Hello, World!" //定义一个变量
var helloWorld: String = "Hello, World!" //一般情况下Swift会自动推断其所属类型,如果想要显示的指定其类型,就在变量名后面跟“: 类型名”
helloWorld += "!" //借鉴了C++里面的运算符重载,追加字符串
println(helloWorld) //后台打印变量"hello"的值
println("hell0 = \(hello)") //在打印的字符串中引入变量
var 你好 = "你好" //Swift中支持几乎所有的Unicode字符,除了数学上的符号、剪头、横杠以及系统关键字以外
let 动物园 = "zoo"
println("\(你好),\(动物园)") //后台打印中文字符的变量,并进行变量拼接
let 动物 = "animal"; let 猴子 = "monkey" //单行创建多个变量或常量其间需要使用";"隔开
let a: Int8 = 8 //整形会自动推断为Int类型(在32位机器上是Int32,在64位机器上是Int64),如果想声明为其他类型,则需要显示指定其类型。
let b = 12.0 //浮点型数据会自动推断为Double类型。
let c: Float = 16.0 //指定浮点型变量为Float类型需要显示指定。
//let d = a + b //两个不同数据类型的常量/变量不能直接进行运算,因为Swift中没有隐式转换,必须开发者显示转换。
let d = Double(a) + b //添加显示转换的两个不同类型的变量间运算,显示转换方式:类型名(常量/变量)
/*
元组分解
*/
let http404ErrorA = (404, "httpRequestError")
println("errorCode = \(http404ErrorA.0)") //通过下标分解元组
println("errorCode = \(http404ErrorA.0), errorMessage = \(http404ErrorA.1)") //通过下标分解元组并拼接字符串
let http404ErrorB = (errorCode:404,errorMessage:"httpRequestError")
println("errorCode = \(http404ErrorB.errorCode),errorMessage = \(http404ErrorB.errorMessage)")
/*
数组,一个数组里只能存储一种类型的数据
*/
var nameArrayA:String[] = ["zhangsan","lisi","wangwu"] //显示表示字符串数组
var nameArrayB = ["zhangsan","lisi","wangwu",32] //显示表示字符串数组
var nameArrayC = [12,22,32,43]
println("nameArrayA = \(nameArrayA)")//
println("nameArrayB = \(nameArrayB)")//
println("nameArrayC = \(nameArrayC)")//
println("nameArrayA = \(nameArrayA),nameArrayB = \(nameArrayB)")
nameArrayA.append("32") //Swift中的数组内只能拼接同一种类型的数据
nameArrayA.removeAtIndex(0) //Swift中移除数组中的一条数据,remove后只是删除了相应字段的内容值,但不会删除字段
nameArrayA[0] = "xingxing" //Swift中修改数组中的一条数据
println("nameArrayA = \(nameArrayA)")
//循环遍历数组(两种方法)
for name in nameArrayA{
println("name = \(name)")
}
for (index, name) in enumerate(nameArrayA){
println("index = \(index),name = \(name)")
}
var person:Dictionary<String, String> = ["name":"zhangsan","sex":"m"] //Swift中定义字典
println("\(person)")
//添加数组成份
person["habit"] = "football"
person["name"] = "gavin"
person["sex"] = "m";
println("person1 = \(person)")
//添加具有相同字段名的成份
person["name"] = "xiaoli"
person["sex"] = "w"
person["habit"] = "read"
println("person2 = \(person)")
//更新数组中相应字段名的数据
let oldName = person.updateValue("baobei",forKey:("name"))
println("person = \(person), oldName = \(oldName)")
//循环遍历字典
for (key, value) in person{
println("key = \(key), value = \(value)")
}
/*
数组可以进行更新,字典不可以更新
*/
var condition = true
var number = 1
/*
if条件语句
*/
//错误if条件语句
//if number { //if条件语句不需要添加小括号,判断条件必须为bool类型数据
// println("do something")
//}
//正确if条件语句
if condition { //if条件语句不需要添加小括号,判断条件必须为bool类型数据
println("do something")
}
/*
for循环
*/
for var i = 0; i < 100; i++ {
print("\(i) ") //不换行打印
println("i = \(i)") //换行打印
}
/*
switch语句
*/
var s = 5
switch s{
case 1:
println("s = 1")
// fallthrough //强制执行下一句
case 2..6: //范围运算符“1..10”:只包括1,不包括10,“1...10”:1和10都包括
println("s = 2")
// fallthrough
case 3..11 where s==10: //双重判定
println("s = 3")
// fallthrough
default:
println("s = other number")
}
var point1 = (3, 4)
switch point1 {
case (0, 0):
println("origion")
case (0,_): //“_”忽略这个位置的值
println("y axis")
case (_,0):
println("x axis")
default:
println("in range")
}
var point2 = (0, 4)
switch point2 {
case (0, 0):
println("origion")
case (0,let y):
println("y axis, y = \(y)") //输出y轴上的值
case (_,0):
println("x axis")
default:
println("in range")
}
/*
——————————optionals可选变量————————————
1.nil:所有类型为空均可使用
2.optionals声明
3.optionals拆包(Forced Unwrapping)
*/
var value: Int?//“?”用在数据类型之后代表为可选类型,值可能为nil
//将字符串转换为Int类型
let numberStr = "12345"
value = numberStr.toInt() //value返回一个bool类型
//解包
if value{
println("value = \(value!)") //"!"表示解包,表示将value中的值取出
var acceptValue: Int = value! //使用“!”可将value中的值取出并赋给其他变量
}else{
}
/*
函数:func 函数名 (参数列表) 返回值 {
实现体
}
*/
func sayHello(name: String) -> String{
return "Hello" + name
}
println(sayHello("zhangsan"))
//函数的类型:参数类型+返回值类型
var funcType1:(String) -> String = sayHello //定义一个名称为"funcType"的函数
func sayGoodBye(name: String) -> String{
return "GoodBye" + name
}
println(funcType1("lisi"))
funcType1 = sayGoodBye
var funcType2:(String) -> String = sayGoodBye
println(funcType1("lisi"))
println(funcType2("lisi"))
func count(name: String) -> (vowels: Int, consonant: Int)
{
var vowels = 0, consonants = 0
for character in name{
var string: String = String(character).lowercaseString
switch string{
case "a","e","i","o","u":
vowels++
case "b","c","d","f","g","h","j","k","l","m","n","p","q","r","s","t","v","w","x","y","z":
consonants++
default:
println("非字母")
}
}
return(vowels, consonants)
}
println(count("woshixingxing"))
var array = count("我是xingxing")
println("vowels = \(array.0) consonants = \(array.1)")
/*
局部变量和外部变量
*/
func join1(string1: String, string2: String) -> String{
return string1 + string2
}
println(join1("Hello"," Xiaoxingxing"))
func join2(externalName1 string1: String, string2: String) -> String{
return string1 + string2
}
println(join2(externalName1:"Hello"," Xiaoxingxing")) //"externalName1"为外部变量名,"string1"为局部变量名
func join3(#string1: String, #string2: String, #joiner:String) -> String{
return string1 + joiner + string2
}
println(join3(string1:"Hello",string2:"xingxing",joiner:"-"))
func join4(#string1: String, #string2: String, joiner: String = "-") -> String{
return string1 + joiner + string2
}
println(join4(string1:"Hello",string2:"xingxing"))
println(join4(string1:"Hello",string2:"xingxing",joiner:"*"))
//println(join3(string1:"Hello",string2:" Xiaoxingxing")) //在"string1"和"string2"前加”#“,"string1"和"string2"既为局部变量名也是外部变量名
func join5(#string1: String, #string2: String,_ joiner: String = "-") -> String{ //”_“取消其外部名称
return string1 + joiner + string2
}
println(join5(string1:"Hello",string2:"xingxing"))
//println(join5(string1:"Hello",string2:"xingxing",joiner:"#"))
println(join5(string1:"Hello",string2:"xingxing","#"))
func caculateMeal(numbers: Double ...) -> Double
{
var sum = 0.0
for number in numbers{ //获取每一个参数的值
sum += number
}
return sum/Double(numbers.count)
}
println("meal = \(caculateMeal(1.0,2.0,3.0))")
func incream(var a: Int,var b: Int)
{
a++
}
var increamNumber = 5
incream(increamNumber, 3) //?待解决
println("increamNumber = \(increamNumber)")
func swapTwoInt(inout a: Int,inout b: Int) //”inout“为可修改关键字,即:传进的参数可以进行修改
{
var temp = a
a = b
b = temp
}
var swapValueA = 3,swapValueB = 5
swapTwoInt(&swapValueA, &swapValueB) //传变量地址进行修改
println("swapValueA = \(swapValueA), swapValueB = \(swapValueB)")
/*
函数嵌套
*/
//外部函数
func stepBackward(number: Int) -> Int
{
return number - 1
}
func stepForward(number: Int) -> Int
{
return number + 1
}
//内部嵌套函数
func changeValue(isStepBackward: Bool) -> (Int) -> Int
{
//被嵌套的函数
func stepBackward(number: Int) -> Int
{
return number - 1
}
func stepForward(number: Int) -> Int
{
return number + 1
}
return isStepBackward ? stepBackward : stepForward
}
var changeValueFunc: (Int) -> Int = changeValue(true)
var changedValue = 3
println("after changed: changedValue = \(changeValueFunc(changedValue))")
var names = ["zhangsan","lisi","wangwu","zhaoliu"]
//var sortedNames = sort(names,{
// (stringA: String ,stringB: String) -> Bool in return stringA > stringB
//})
//自动类型推断
var sortedNames = sort(names,{
(stringA ,stringB) -> Bool in return stringA > stringB
})
println("sortedNames = \(sortedNames)")
//var sortedNmaes = sort(names,{stringA,stringB->Bool in stringA > stringB})
//var sortedNmaes = sort(names,{$0>$1})
var sortedNmaes = sort(names,>)
//如果函数中有闭包的话就把闭包放到外面 并且闭包参数是最后一个 例如:
var sortedNmaes1 = sort(names){
$0>$1
}