Swift基础知识点

swift用起来刚开始感觉有点怪怪的,但用了一段时间觉得还是挺好用的,哈哈.毕竟都是要有一个过程的嘛.

我就写一些自己在使用swift的时候的注意点吧,如有不正之处,还请指正!

一.在开发中优先使用常量,只有发现该标识符需要修改的时候,再改成变量,这样做可使数据更安全,以防止队友不小心把你的值修改了.

二.创建一个对象的时候,比如创建一个UIView对象

//1.创建UIView对象
let rect : CGRect = CGRectMake(0, 0, 100, 100)
let view : UIView = UIView(frame: rect)
//2.修改UIView内部属性
//2.1修改view的透明度
view.alpha = 0.5
//2.2 修改view的背景色
view.backgroundColor = UIColor.redColor()

//3.创建UIButton对象
/*
    在swift使用枚举类型,有2种方式
    1.枚举的类型.具体的类型
    2.直接点-->   .具体的类型
*/
let btn : UIButton = UIButton(type: .Custom)
//4.修改btn的内部属性
btn.frame = CGRectMake(0, 0, 50, 50)
btn.backgroundColor = UIColor.greenColor()
btn.setTitle("按钮", forState: .Normal)

view.addSubview(btn)

//5.在swift中也能这样添加一个按钮
let rect1 : CGRect = CGRectMake(0, 0, 20, 20)
let btn1 : UIButton = UIButton(frame: rect1)
btn1.backgroundColor = UIColor.grayColor()
view.addSubview(btn1)

三.swift中的类型推导,首先swift是强类型语言,然后他的每个标识符都有自己的类型.注意的一点是,例如

//let a : Int = 10
//可直接写成
let a = 10

var c = 1.44
c = 20
//修改后会把20当成20.0来看 所以不会报错

var b = 20
// b = 1.44 错误写法

四.swift中的基本运算需要注意的就是swift中没有隐式转换,所以当类型不同的时候不能运算,要先转换成同一类型:

1>Double -->Int         Int (b)

2>Int -->Double         Double(a)

五.逻辑分支中,有if,switch,guard,while,do While(do-->repeat)等,共同的地方都是能省去()

　　1>一,if后面的判断没有非0(nil)即真  二,if后面判断句必须有明确真假(Bool -->true / false)

2>一,switch的case后面不用加break,编译器会自动加.  二,case后面可以接多个判断条件,并且以","隔开  三,有时候需要穿透的话,自己在case后面加上fallThrough

switch比在OC中更强大的地方在于,它支持多种数据类型,包括  1--->浮点型;  2-->字符串;  3-->还能判断区间

半开半闭区间的表示方法:例如1..<10 --->[1 10)

闭区间的表示方法 :  例如 1...10  ---->[1 10]

这就不写demo了,用起来还是挺方便简单的.

　　3>guard翻译过来中文就是守卫,门卫的意思,它就是一层一层条件判断,全部通过后最后执行后面的的代码块,例如

let age = 20
let money = 20
let id = 1

func online(money : Int,age :Int ,id :Int){
    //1.判断年龄
    guard  age >= 18  else{
        print("回家去")
        return
    }
    //2.判断是否带了身份证
    guard id >= 1   else{
        print("回家拿身份证")
        return
    }
    guard money >= 10 else{
        print("回家拿钱")
        return
    }
    print("上机")
}
//调用的时候,最前面的参数不用传键值对,传个值就行
online(money,age :age ,id: id)

　　4>do While---->用法在swift里面把do换成repeat就行了.其他的和OC中差不多.

六.字符串的基本使用.例如

//1.定义字符串
    //1.1 定义不可变字符串
    let str = "hello world"
    //1.2  定义可变字符串
    var strM = "hello swift";
    strM = "hello OC"

//2.字符串的使用
    //2.1 遍历所有字符串
for c in str.characters{
    print(c)
}
    //2.2 获取字符串的长度
let length = str.characters.count

//3.字符串的拼接
    //3.1 两个字符串直接的拼接
let str1 = "s"
let str2 = "j"
let str3 = str1 + str2
    //3.2 字符串和其他标识符的拼接
let name = "cjh"
let sex = "man"
let person = "my name is \(name),is \(sex)"
    //3.3 拼接过程格式化
let min = 2;
let second = 22;
let time = String(format: "%02d:%02d", arguments: [min, second])

字符串的截取,例如

let str = "www.baidu.com"
//1.方式一:将String类型转成NSString类型 as就可以进行转化
let header = (str as NSString).substringToIndex(3)
let footer = (str as NSString).substringFromIndex(10)
let range = NSMakeRange(4, 5)
let middle = (str as NSString).substringWithRange(range)

//2.方式二: 使用String类型的方法
let endIndex = str.startIndex.advancedBy(3)
let header1 = str.substringToIndex(endIndex)

let startIndex = str.endIndex.advancedBy(-3)
let footer1 = str.substringFromIndex(startIndex)

let range1 = Range(start: endIndex.advancedBy(1), end: startIndex.advancedBy(-1))
let middle1 = str.substringWithRange(range1)

七.关于swift中的数组,基本用法倒是容易,我觉得要注意的就是当两个相同类型的数组需要合并的时候,直接相加就行了,但是当两个不同的类型的数组需要合并的时候,需要先自己转换类型为NSObject的类型了.例如

//1.定义数组
    //1.1 定义不可变数组
let arr = ["a","b","c"]
    //1.2 定义可变数组
var arrM = ["aaa","bbb"]
//2.对可变数组的基本操作
    //2.1 添加元素
arrM.append("ccc")
arrM.append("ddd")
    //2.2 删除元素
arrM.removeAtIndex(2)
print(arrM)
    //2.3 修改元素
arrM[0] = "zzz"
print(arrM)
    //2.4 获取元素
arrM[1]

//3.遍历数组
//3.1 最基本的遍历方式
for i in 0..<arr.count{
    print(arr[i])
}
//3.2 遍历数组中的一部分元素
for i in 0..<2{
    print(arr[i])
}
for name in arr[0..<2]{
    print(name)
}
//3.3 for 增强遍历
for name in arr{
    print(name)
}
//3.4  下标 和元素 都获取
for(index,name) in arr.enumerate() {
    print(index)
    print(name)
}
//4.数组的合并:如果两个数组类型一致,直接相加
let arr1 = ["abc","def"]
let arr2 = ["abc","aaaa"]
let arr3 = arr1 + arr2

//
//如果类型不一致,转换成NSObject,再遍历另一个元素全部加进去
let arr4 = [1,2,3]
let arr5 = ["a","b"]

var arr6 = [NSObject]()
arr6 = arr5

arr6.append("c")

for name in arr4{

    arr6.append(name)

}

print(arr6)

八.关于swift中的字典.例如,在swift字典里的删除元素方法有几个,有个方法

removeAtIndex(<#T##index: DictionaryIndex<Hashable, Value>##DictionaryIndex<Hashable, Value>#>)要传一个index,真是纠结啊,字典不是无序的啊,索引怎么传啊,研究了半天,终于搞定了怎么传.

//1.定义字典
    //1.1定义不可变字典
let dict1 = ["name":"jack","age":18]
    //1.2定义可变字典

var dict2 = ["sex":"man","country":"china","age":11]

//2.对字典的基本操作
    //2.1 添加元素
dict2["name"] = "lucy"
dict2.updateValue(1.7, forKey:"height")
dict2
    //2.2删除元素
dict2.removeValueForKey("sex")
//1.7 == dict2["height"]!
//("height",1.7) == dict2[0]
//let index = dict2["height",1.7]

/*
还有一个方法
removeAtIndex(<#T##index: DictionaryIndex<Hashable, Value>##DictionaryIndex<Hashable, Value>#>)
官方文档是这样说的,借助百度翻译翻译结果如下
Used to access the key-value pairs in an instance of Dictionary<Key, Value>.
用于访问字典<键、值>的实例中的键值对。
Dictionary has two subscripting interfaces:
字典有两个操作界面：
Subscripting with a key, yielding an optional value:
下标有键，产生一个可选值：
v = d[k]!
Subscripting with an index, yielding a key-value pair:
下标有索引，产生一个键值对：
(k,v) = d[i]
*/
dict2.removeAtIndex(dict2.indexForKey("height")!)

print(dict2)
    //2.3修改元素
dict2["age"] = 20
print(dict2)
dict2["height"] = 1.8
print(dict2)
    //2.4 获取元素
dict2["name"]
let v = dict2.indexForKey("height")
print(v)

//3.遍历字典
    //3.1 遍历字典中所有的key
for key in dict2.keys{
    print(key)
}
    //3.2 遍历所有的value
for value in dict2.values{
    print(value)
}
    //3.3 遍历键值对
for (key,value) in dict2{
    print(key)
    print(value)
}
//4.字典的合并 : 任何情况不能相加
let dict3 = ["name":"cjh","age":10]
var dict4 = ["sex":"man","height":1.7]
for(key,value) in dict3{
    dict4[key] = value
}

ok,就这样了.　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　奈文摩尔 16.5.11