SWIFT基础笔记
swift⼤⼩写敏感
swift输出⽅法println()
swift声明变量var 声明常量let  需注意 let常量只能再初始化时进⾏赋值，var变量可以在任何时候赋值
swift在println中输出多个变量的⽅法为println(“\(val1),\(val2),…”) 即在双引号中⽤\(var) 来输出变量
swift对数字整型有Int Int8 Int16 Int32 Int64位⼏种类型。其中Int会根据当前操作系统⾃动转换为当前系统位数的整型类型。例如当前系统是32位，则Int 实际上就是Int32
swift获取数据类型范围的⽅法：以Int整型为例，Int.max为获取该类型的最⼤值 Int.min为获取该整型的最⼩值
swift中如果想提⾼数据可读性的话，可以将1000000写成1_000_000 这样写不会影响程序的执⾏，⼜可以提⾼代码的可读性。
swift设置数据进制：⼆进制0b  ⼋进制0o ⼗六进制0x
swift字符串中的转意符：\0（null字符）， \\（反斜杠），\t（制表符），\n（新⾏符），\r（回车符），\”（双引号），\’（单引号）
swift单字节Unicode字符，使⽤\xnn表⽰，其中nn代表两个⼗六进制的数
例如：
let str ＝ “\x41″
输出为“A”
swift双字节Unicode字符，使⽤\unnnn表⽰，其中nnnn代表4个⼗六进制数
例如：
let str2 ＝ “\u2600″
输出为＊
swift四字节Unicode字符，使⽤\Unnnnnnnn表⽰，其中nnnnnnnn代表8个⼗六进制数
例如：
let str3 ＝ “\U0001F496″
输出为⼀个特殊字符
swift字符串⼤⼩写转换：
let small_string = “abcd”
let big_string = “ABCD”
println(small_string.uppercaseString)
println(big_string.lowercaseString)
如上所⽰，.uppercaseString为转化为⼤写 .lowercaseString为转化为⼩写
swift中的for循环写法：
for key in value{
println(key)
}
swift返回字符串长度：countElements(string)
swift返回字符串各字符的unicode字符编码：
for c in string.unicodeScalars{
print(“\(c.value)\n”)
}
swift元数组类型的操作⽅法：
let name = (value1,vlaue2,value3)
其中，值可以引⽤其他变量或常量
let (var1,var2,var3) = name
可以将之前定义的元数组中的值，赋值给声明的3个变量，并且按顺序⼀⼀对应
let (_,var2,_)=name
如果只取其中某⼀个，或者多个值时，不需要的的值需要⽤下划线代替
let name = (var1:value1,var2:value2,var3:value3)
可以在定义元数组时给元素命名，使⽤时只需要name.var1 调⽤即可。与javascript⾮常相似
swift中的nil通过包含另⼀个值或者包含nil来指明该值不存在。通过在类型后⾯添加问号(?)来标记⼀个值为可选值。例如：var value1:Int?=nil 设置⼀个可选值。当然，默认情况下，在表达式后加上问号将会⾃动为变量设定nil值，例如：var value2:Int?
但是需要注意，nil只能赋值给optional类型（即可选类型）。不能直接赋值给⾮可选类型，例如：var value:Int ＝ nil 这样是错误的。
可选类型的值，访问时需要再转换后的变量后加上! 才可以单独调出可选值中的内容。如下例所⽰：
var str = “123″
var num:Int? = Int()
var num2 = num! + 100  //输出223
demo中，将字符串str的123转换为Int数字整型，转化为成功后，变量num的实际内容为{some,123} 此时如果使⽤print打印的画，不会有任何问题。但是不能直接⽤于计算，如上例：num2中如果num后没有! 则会报错。因此这⾥可以理解为，带有可选值的变量后跟上⼀个!可以将可选值中的有效值提出，并进⾏计算。
swift⾃定义类型：
typealias ID = UInt8//⾃定义类型ID
var max = ID.max //查询类型ID的最⼤范围
var id:ID = 20; //将id变量的类型设置为ID并将值设置为20.如果超出范围会报错
swift 类型转换：
字符型String 转换为整型Int时使⽤ .toInt()⽅式。如下例⼦
var str_num:String = “123456″
var int_num:Int? = Int()
将字符类型变量str_num转换为Int类型并赋值给int_num。这⾥需要注意的时，如果给int_num指定类型的话，必须在类型后⾯加上?即可选值。因为字符串不确定性很多，很多
情况下转化为Int类型时会带有字符。因此需要为其设置可选值，当转换的字符串型中包含字符时，会显⽰nil。⼀般情况下如果不需要给变量指定类型的话，可以不需要加?
例如：var int_num = Int()
其他类型转换为字符串型使⽤toString()的内置⽅法。如下例⼦
var int_num2 = 123456
var str_num2 = toString(int_num2)  //转化为字符串”123456″
var str_num3 = toString(true) //将布尔型转换为字符串true
运算时得数据类型转换，简单得记忆⽅式为，需要转换得类型(变量)。例如要转化为int16类型，则：Int16(int_num2)
如果要转化为Float类型则为：Float(int_num2)
下⾯列⼏个数据转换与计算时得⼀些特性，如下：
var str:Int8 = 100
var str2:Int16 = 200
var str3:Int16 = Int16(str) + str2
str为Int8类型，str2为Int16类型。如果两个数字相加的时候，必须先将str转换为Int16格式再相加。因为swift为了避免精度的丢失，需要显式的将Int8类型转换为相同的类型。注
意！这⾥不能将str2转换为Int8格式进⾏计算。
简单的记忆⽅法为，可以⼤转⼩，不能⼩转⼤。
var intNum:Int = 100
var floatNum = 1.911
var tol = intNum + Int(floatNum)  //输出101
上述例⼦中，是⼀个整型与浮点型之间的运算。其中intNum为Int类型，floatNum为Double类型。如果两个类型进⾏相加的画，必须将其中⼀个类型转换为另外⼀个数据的类型
才能正常运算。例中将floatNum转换为Int类型，转换并进⾏计算后结果为101。说明floatNum通过类型转换后，将⼩数点后的数据全部舍弃，使floatNum的值变为1。⽽变量tol
如果不指定任何类型的画，会⾃动转换为右侧表达式中，正常计算的类型。
swift中空字符串的声明⽅式为：var str = “” 或者 var str = String()  判断字符串是否为空的属性为.isEmpty 使⽤该属性后，结果以布尔型输出
swfit数组的基本语法为[value1,value2,value3,…..]
swift中数组声明时可以为数组指定类型，也可以不为数组指定类型。
如例：
var gril = [“hanmeimei”,30,“teacher”]
声明的gril数组中包含字符串和数字整型，由于数组没有指定相应的内容类型，因此这样写时合法的。
⽽如下例：
var gril:String[] = [“hanmeimei”,30,“teacher”]
声明数组时，为数组内容指定了String类型。如果这样设置的话，程序就会报错。因为其中30时整型类实数，如果⼀定声明类型的话，请务必将数组的内容转换为同⼀类型.
swift追加与删除数组元素的⽅法如下例：
var gril = ["hanmeimei","30","teacher"]
gril.append(“china”)  //使⽤append⽅法，该⽅法在数组最后追加⼀个元素
gril.insert(“female”,atIndex:1)  //使⽤insert⽅法，该⽅法时在数组的指定位置插⼊⼀个值。0为起始位置
gril += ["is mother","has one children"]  //使⽤＋＝的形式拼接数组，拼接的内容会追加到数组的尾部
swfit中遍历数组的⽅法有两种：
1.for in 例如：
for key in gril{
println(key)
}
2.有循环变量的遍历⽅式，可以获得数组的下标，例如：
for (index,value) in enumerate(gril){
println(“下标为\(index)，值为\(value)“)
}
此⽅法⾸先使⽤enumerate⽅法，将gril数组元素处理为元数组类型，即每次遍历都会对应(index,value)进⾏赋值
swift中字典的基本语法为：[key1:val1,key2:val2,key3:val3,…]
如例：
var city:Dictionary<String,String> = [“key1″:“wuhan”,“key2″:“kunming”,“key3″:“changsha”]
创建⼀个city的字典，上例中为字典指定了模版，即Dictionary<String,String> 代表指定字典的key为字符串格式，val也为字符串格式。在这⾥为字典的key 和 val设置格式时，需
要注意所属类型的范围。
city[“key4″] = “guangzhuo”  //向字典中追加key4 值为guangzhou
switch case判断字符串当然了，修改对应键值的内容，也可以使⽤这种⽅法，值需要为指定的键赋值即可
字典也可以使⽤.count属性来获取字典键值的对数
关于swift删除字典的操作⽅法，⽤下⾯的实例来解说：
if let removeValue = veValueForKey(“key2″){
println(“删除的键值为\(removeValue)“)  //打印kunimng
}else{
println(“没有到对应的\”key2\”的键”)
}
上述实例中，使⽤了removeValueForKey⽅法。该⽅法查key2键，并将其删除，返回其键的值。其中if表达式中，先判断key2是否存在。如果key2存在，返回true，且返回被删除的键值，然后将值赋值给removeValue。
swift对字典的遍历也有两种⽅法，如下：
1.for in 例如：
for (index,value) in city{
println(“键\(index)，值\(value)“)
}
2.遍历键和值的⽅法：
for citykey in city.keys{
println(citykey)
}
for cityname in city.values{
println(cityname)
}
如上例，遍历key可以使⽤.keys属性，如果只是遍历值的话可以使⽤.values属性
实际上，.keys和.values两种属性还可以结合Array()函数将取出的键或值转换为数组，如下：
let cityarray = Array(city.values)  //输出[changsha, guangzhuo, wuhan]
swift分⽀语句包含以下两种：
if else语句与其他程序⼀致，不做介绍。
switch语句，与其他程序有较⼤的区别，做了很多的优化，此处使⽤⼀个实例来说明，如下：
let number = 12
switchnumber{
case 1,2,3,4,5,6,7,8,9,10:
println(“1-10的数字”)
case11,12,13,14,15,16,17,18,19,20:
println(“10-20之间的数字”)
default:
println(“数字不在⽅案范围之内”)
}
let number2 = 1_000
switch number2{
case 0 :
println(“0″)
case 1…10:
println(“1-10″)
case 11…100:
println(“11-100″)
case 101…1000:
println(“101-1000″)
case 1001…10000:
println(“1001-10000″)
default:
println(“不在⽅案范围内”)
}
通过上述两个例⼦，可以发现swift中的switch语句省去了每个⽅案的break（实际可以理解为⾃动加⼊了break并不显⽰），切 case⽅案可以为任何类型的值，都可以进⾏判断。case⽀持多个值的筛选，如val1,val2,val3,… 或者值的范围筛选，如n1…n2
swift的循环语句包含四种：
1.while 语句，与其他程序语句相同，不做介绍
var i = 0
while 100 > i {
println(i)
i++
}
2.do while语句
var n = 0
do{
println(n)
n++
}while100>n
3.for 循环
for var i=0; i<100; i++ {
println(“数字\(i)“)
}
4.for in 循环主要⽤于遍历
/
/1.遍历范围
for index in 1…5{
println(index)
}
//2.忽略循环变量，仅⽤于计算变量，不过⼀般这种情况更适合⽤for或者while来处理
let base = 3
let round = 20
var point = 1
for _ in 1…round{
point *= base
}
println(“point是\(point)“)
//3.遍历数组
let array = ["val1","val2","val3"]
for key in array{
println(key)
}
//4.遍历字典
var city:Dictionary<String,String> = ["key1":"wuhan","key2":"kunming","key3":"changsha"] for (index,value) in city{
println(“键\(index)，值\(value)“)
}
//5.遍历字符串
var str2 = “swift”
for key in str2{
println(key)
}
swift跳转语句
continue实例，终⽌当前循环，并执⾏下⾯的循环
for var i = 0; i<100; i++ {
if i%10 == 0{
continue;
}
println(i)
}
2.break语句
break实例，终⽌当前循环，并结束剩余的循环
for var i = 0; i<100; i++ {
if i == 10{
break;
}
println(i)
}
3.fallthrough语句
可以让switch语句中的⽅案选择继续贯穿下去，类似于其他语⾔中，case语句后没有加break的效果。
let number2 = 1_000
switch number2{
case 0 :
println(“0″)
case 1…10:
println(“1-10″)
case 11…100:
println(“11-100″)
case 101…1000:
println(“101-1000″)
fallthrough//让⽅案匹配继续贯穿下去
case 1001…10000:
println(“1001-10000″)
default:
println(“不在⽅案范围内”)
}
⼀般多⽤于函数中的返回值所⽤，和其他程序基本类似，不做介绍
swift函数的定义⽅式，如下实例：
1.⽆值返回函数
func ourput(name:String,put:String) {
println(“名字\(name)，输出\(put)“)
}
2.有值返回函数
func ourput(name:String,put:String) -> String {
println(“名字\(name)，输出\(put)“)
return name+put
}
函数参数后⾯的->String是设定返回函数的类型，如果指定了类型则必须有return语句，有return语句，则必须为返回值设置类型
3.多值返回函数
func many(in1:String,in2:String,in3:Int) -> (set1:String,set2:String,set3:Int){
var str1 = in1,str2 = in2,num = in3
str1 += str2 + String(num)
return (str1,str2,num)
}
println(many(“d1″,“d2″,3))
4.嵌套函数
//嵌套函数
func gotheway(Direction:Bool) -> (Int) -> Int {//返回值实际上是嵌套中的函数指针，所以还要为嵌套函数传⼊的参数设定类型，即(Int)
func gofront(input:Int) -> Int {return input +  1}
func goback(input:Int) -> Int {return input – 1}
return Direction ? goback : gofront
}
var currentways = -4
let movetozero = gotheway(currentways > 0) //由于gotheway为假，所以此时的movetozero实际上是嵌套函数中的gofront。注意，此处的gotheways只能传⼊布尔类型，因为这个函数只有⼀个布尔类型的参数。只有为函数传⼊对应的参数后，gothew  whilecurrentways != 0{
println(currentways)
currentways = movetozero(currentways)
}/*******************************************************************/
⼀、常量 & 变量
//常量
let constantsTeam = 1
//变量
var variablesTeam = 2
  尽可能使⽤常量，这样更清晰并且内存更不容易肾亏。
⼆、显⽰/隐式指定类型
//隐式
let inferredTeam = 3
//显式
let explicitTeam:Int = 4
三、字符串输出

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。