# Swift2.0基本语法 常用数据类型

基本语法

名称	作用
print	控制台输出语句
var	声明一个变量
let	声明一个常量
if…else..	判断语句
switch…case..	分支语句
for	循环语句
while	判断循环语句,先判断后循环

print

向控制台输出文本log

print("hello world")//输出纯字符串
print("1 + \(1) =?")//输出字符+数字的组合 这里使用了字符串插值`\()` 括号内可以接受任何内容 输出结果:1 + 1 =?
var a:floata: = 2.1
print("1 + \(a)")  //输出字符+变量 输出结果:1 + 2.1

var

声明一个变量.变量表示可以修改的数据类型 可以赋值多次

例子:

var a:Int = 0
a = 100 //可以再次赋值
var b:NSObject = NSObject()

let

声明一个不可变的常量,只能赋值一次

例子

let a:Int = 0
a = 100 //这句代码会报错 不可以再次赋值

if…else

条件判断语句,和OC中得语法主要有三点区别

• 条件并非必须在小括号中
• 条件必须是明确的true或者false 0或非0 并不会隐式的转换为true或false,nil和非nil同样不会隐式转换
• 执行语句必须包含在大括号中

例子:

let a:Int = 0
if a = 0 {
    //条件成立执行
    a = 100
}else{ 
    //条件不成立执行
    a = 50
}

switch

关键字:

• switch 判断语句首要关键字
• case 节点关键字,每个判断的节点使用
• fallthrough 不跳出判断,继续向下执行
• default 例外,没有条件成立时执行此语句
• where 判断子语句 相当于 if 语句中得 &&

在swift中switch语句默认只匹配一个case这和其它类C语言不通,类C语言中,如果不使用关键字break,那么将执行匹配到的case节点下面所有的代码,而在swift中,不需要break语句来进行跳出,默认原则就是只执行匹配到的节点与下个节点之间的代码.并且不需要大括号进行包裹,如果想执行后面的语句可以加上fallthrough语句.

let a = 0;
switch a {
    case 0://遇到节点 匹配相同 条件成立 执行后面的语句
        print("0") //输出0
        fallthrough //执行下一个节点中得内容
    case 1: //匹配失败 这个条件并不成立 但是也会执行,因为上一句中得关键字fallthrough 所以这个节点中得代码被执行了
        print("1")//输出1
    case 2:         //匹配失败 不执行
        print("2")
    default:        //默认节点 不执行
        print("3")
}
输出结果 0 1

在swift中switch语句更加的强大,不仅能判断进行普通的常量匹配还支持范围匹配,元祖匹配,和where子语句匹配.

1.范围匹配

let a = 5;
switch a {
    case 0...10://匹配a是否在0 - 10这11个值之内
        print("0")
    case 0..<10://匹配a是否在0 - 9这10个值之内 虽然条件成立但是由于第一个条件已经成立所以这里不会进入判断
        print("1")
    default:
        print("2")
}
输出结果:
0

2.元组匹配

let a = (1,2,"A");
switch a {
    case let b://配皮元祖 绝对匹配的写法
        print("\(b.0)")//输出元组的第一个参数 这里输出:1
    case (1,2,let c)://匹配第一第二个参数,将第三个参数赋值给c 
        print("\(c)")//这里输出:A
    case (_,let c,"A")://第一个参数忽略匹配,第二个参数赋值给c 匹配第三个参数"A"
        print("\(c)") //这里输出:2
    default:
        print("2")
}
输出结果:
1

更多方法可以参考元祖的使用

3.where语句

let a = 1;
switch a {
    case 1 where false://匹配是否为1 并且where后面的bool值为true 这里条件不成立所以不会运行
        print("1")
    case 1 where a == 1://这里匹配成功并且 where后面值也为true 所以下面代码会运行
        print("2")
}
输出结果:
2

附注:

• swift中switch默认只匹配一个case,如果需要匹配多个则需要加上fallthrough关键字
• swift中switch没有break,如果在switch中使用break,不是跳出switch而是跳出更外层的范围.

for

与oc相比不需要对循环条件加括号了,新增区间运算符...和..<代替了i = 0 i < 10 i++这种形式

for i in 0..<10{ //0..<10 表示0-9的数字 这是半开区间,还一种全开区间0...10 表示0-10的数字
    print("i = \(i)")
}
效果等同于:
for var i = 0;i < 10; i++{
    print("i= \(i)")
}

同样for - in形式可以用于数组,和OC相同,由于swift是强类型语言并且支持类型推断,所以在for- in中可以不去声明类型

var a:[Int] = [1,2,3,4,5]
for i in a{ print("i = \(i)") }
输出结果:
i = 1
i = 2
i = 3
i = 4
i = 5
是不是比oc简单的多

while

和oc基本没有区别,条件无需小括号

var a = 1;
while a < 10{
    a++
    print("a");
}
//这个循环首先会判断a是否小于10 条件成立才进入循环块中执行代码,每执行一次判断一次,直到条件不成立才会继续向下运行

var a = 1;
repeat{//swift中 do换成了repeat 作用一样
    a++
    print("a")
}while a < 10
//这个循环会首先进入代码块执行一遍块中的代码,然后再进行条件判断

关键字

break这个关键字可以强制跳出循环. continue终止当前循环,开始下一次的循环.

var i:Int = 0;
    repeat{
        i += 1
        if i >= 10 {
            break //当条件成立时 跳出当前循环 执行循环后面的代码
        }
        if i%2 == 0{
            continue //当条件成立时 结束当前循环,进行下一次循环
        }
        print("i = \(i)")
}while true //死循环
print("end")

输出结果:
i = 1
i = 3
i = 5
i = 7
i = 9
end

基本数据类型

• 在swift中,基本数据类型也拥有各自的方法.通过方法可以对数据进行更改.比如Int.min 就能得到Int所能储存的最小值 a.hashValue a是整数 可以得到哈希值
• swift是一个强类型语言,任何类型的值都不能隐式的转换成另外一种类型,需要转换时可以使用Int(b)讲b显式的转换成Int类型

名称	说明
整型	包含Int Int8 Int16 Int32 Int32的有符号整型和UInt8 UInt16 UInt32 UInt64的无符号整型
浮点型	Float和Double,默认为Double类型的
布尔型	true和false 放弃了OC中得YES和NO 不支持隐式转换,0和非0不在代表false和true
字符串	string 类似脚本语言的string 可以直接链接字符串和追加字符
数组	不同于OC数组只能包含OC对象 swift数组可以包含所有对象
字典	同样可以包含所有对象,key值也可以是任意的基本数据类型

整型

只能储存整数,默认推断类型为Int

var a = 10 //a是Int类型的
Int.max //取一个最大得值
Int.min //取一个最小的值

浮点型

默认推断类型为Double类型,Float32位 Double64位与设备的架构无关

var f:Float = 2.2

布尔型

在swift中,0不代表false 非0也不代表true nil也不会等于false 所以的值都是唯一类型的,无法隐式的转换.所以说if(1)这样的写法也将不可用

字符串

swift中添加了新的字符串类型string 如果使用cocoa库的话NSString依旧可以使用.string是Character类型值得集合,每个Character代表一个Unicode字符.因为每个字符大小不同,所以无法通过string占用内存大小来获得字符串的长度.

//创建
var str:String = "asA中⬇️"
//获取长度
print(str.characters.count);    //输出结果:5
//字符串拼接
let newStr = str + "123"
print("拼接后的字符:\(newStr)") //输出结果:asA中⬇123
//字符串追加
str += "456"
print(str)  //输出结果:asA中⬇456
//取首字符
print(str.substringToIndex(str.startIndex.advancedBy(1)))   //输出结果:a
//取尾字符
print(str.substringFromIndex(str.endIndex.advancedBy(-1)))  //输出结果:6
//取字符中间
let start = str.startIndex.advancedBy(1)
let end = str.endIndex.advancedBy(-1)
print(str[start...end]) //输出结果:sA中⬇456
//取字符在字符串中的位置
let r:Range? = str.rangeOfString("sA")
print(r!)   //输出结果:1..<3
//删除字符
str.removeRange(r!)
print(str)  //输出结果:a中⬇456
//遍历字符
for c in str.characters {
    print(String(c))//依次输出:a, 中, ⬇, 4, 5, 6
}
//比较字符
let a = "a"
let b = "b"
print(a == b)  //输出结果:false

在string中,于NSString的使用方法有了很大的不同,语法更加简洁,更加贴合数值类型的操作习惯,支持范围区间符号...非常方便的就能获取范围,字符串的拼接和追加也不再需要代码直接使用+号就能完成.同时比较字符串和遍历字符串使用起来也非常的方便.

数组

首先和oc中不同的是,swift数组可以储存任何类型,包括基本数据类型如:Int,String等,再者swift数组只能储存相同的数据类型,这样可以确保从数组中获得的数据类型是一致的,从而避免一些错误.

//创建
var array1:[String] = ["a","b","1"]
var array2:[String]
var array3:Array<Int> = [1,2,3,5]
//查询下下标
array1.count  //输出结果为:3
//遍历
for a in array1 {
    print(a) //依次输出:a, b, 1
}
//增加
array1.append("c") //array1结果为:["a","b","1","c"]
//删除
array1.removeAtIndex(1) //array1结果为:["a","1","c"]
//取元素
print(array1[0])    //输出结果为:a
//取范围内元素
print(array1[0...2]) //输出结果为["a","1"]
//替换元素
array1.insert("z", atIndex: 0) //array1结果为:["0","1","c"]
//判断是否为空
print(array1.isEmpty) //输出结果为:false

1. 需要注意的是,在数组中如果储存的值是基本类型,结构体或枚举则数组将数据copy到数组中,修改外部数据或数组中的数据是不会对另外一方造成影响的

   var a = 1,b = 2,c = 3,d = 4
   var all:Array<Int> = [a,b,c,d]
   a = 11
   print(all[0])//虽然a的值变成了11 但是对数组中的数据没有影响 这里输出:1

2. 如果是类对象,则是引用到数组中,对任何一方的改变都会影响到另外一方的值.

   var a:UIView = UIView()
   let all = [a]
   print(all[0].tag)//输出结果:0
   a.tag = 1           //修改a.tag的值,数组第一元素的tag值也会跟着改变
   print(all[0].tag)//输出结果:1

字典

在swift中,任何遵循Hashable协议的类型都可以作为字典的key,而所有的基本类型都遵循Hashable,所以它们都可以作为key来使用,而oc中只有NSString类型可以作为key.字典可储存的类型和Array相同都可以储存任何形式的值.不同于OC中的字典只能储存NSObject对象.

//创建
var dic = ["a":1]
var dic1:Dictionary<String,Int> = [:]
var dic2:[String:Int] =  Dictionary()
//获得元素数量print(dic.count)
//遍历数组
for (str,number) in dic {
    print(str + " " + String(number))
}
//添加元素
dic["b"] = 2
//删除元素
dic.removeValueForKey("a")
//更改元素
dic["b"] = 3
//通过key获取值
print(dic["b"]!)

注意:字典中的value值是可空属性,所以需要使用 ! 来强制解包,当然为了安全起见每次强制解包之前都需要判断一下是否为空.如果不明白 ! 的作用可以看我另外一篇博客,其他的用法都比较简单就不多介绍了.