Swift学习笔记

>在swift中=前后一定要用空格隔开,不然会报错的 >常量和变量的使用,

//常量以 let 修饰
	常量指向的内存地址是不可以修改的,但是可以修改内部的属性
	let a : int =20
	let修饰,a不可以在重新的进行赋值
	let a : UIView = UIView();  
	例如指向的是一个对象,可以修改对象内部的属性 例如:
	a.alpath = 0.5;//可以设置内部的属性
	
//变量以 var 修饰
	var a : int =20

>对象

//创建对象 OC 中的写法
UIView view = [[UIView alloc]init];
//创建对象 swift中的写法
let view : UIView = UIView();  //

>类型推导意思是可以根据赋值,系统会自动推导出前面的类型,类型可以省略不写,举例

let a : Int = 20
let a = 20

let view : UIView = UIView()
let view = UIView();

>基本运算在swift中不同类型是不可以进行计算的,例如一个double类型与int类型进行运算,唯一的办法可以进行转换,例如

let a : Int = 20
let b : Double = 12.2
let c = a + Int(b)  //必须进行转换,才能计算
//一般如果一个变量+1的话,我们经常这样写a++,但在swift中正确的写法是a+=1
a+=1 //表示a+1=a

>逻辑分支判断语句中没有YES 和 NO,都以true 和 false 替换掉了

let a : Int = 10
if a>80 {           //可以省略()
   print("进来了")
}

//guard 的使用,guard是Swift2.0新增的语法 类似于if
//oc写法
func onlinre (age : Int){
    if(age > 8){
        print("大于8")
    }else{
        return
    }
    
}


//swift写法
func onlinr (age : Int){
    guard age > 8 else {
        return
    }
    
    print("大于8")
    
}
onlinre(age: a)
onlinr(age: a)

>switch语句中break可以省略 switch后面的()也可以省略

let a = 2
switch a {
case 2,3:
   print("hahah ")
    fallthrough //这个值表示可以直接跟着下面那个条件一起成立,也就是说如果2,3满足,也会直接进行走下面的语句
case 12:
    print("hahah ")
default:
    print("nihao ");
}

>关于区间 swift中的区间分为半开半闭区间和闭区间 //描述0-9的所有数据 1.半开半闭区间 0..<10 2.闭区间 0...9

>关于for循环

//表示打印0-10的所有数字,注意是三个点
for i in 0...10 {
    print(i)
}

//表示打印0-9的所有数字,注意是两个点,后面再加上运算符
for i in 0..<10{
    print(i)
}

//如果i没有被使用的话,可以在前面加上_,优点不占用内存空间
for _i in 0..<10{
    print("hah")
}

>字符串在oc中使用NString swift中使用String String是一个结构体,性能比OC好

let str : String = "哈哈哈"
let str2 : String = "哈哈哈"
print("我打印了\(str2)")//类似于oc中 NsLog("我打印了%@",str2)


let a = 4;
let b = 5;
let ss = String(format: "%02d:%02d",a,b)//转化为 04:05
print(ss)

//(name as NSString)  as表示将String 转化为 NSString
let name : String = "我是唐林渊"
(name as NSString).substring(to: 2)

>数组的几种写法

var array = ["a","b","c"]
var array1 : Array<String> = ["a","c"];
var array2 = [String]()

 array.append("哈哈")//添加
 array[0] = "aa"//修改
    print(array.count)
 //array.removeAll()//删除

//遍历的两种方法


//第一种只能发到对应的值
for i in array {
    print(i)
}

//第二种  既可以拿到index 也可以拿到对应的item
for (index1,item1) in array.enumerated(){
    print( String(format: "当前的下标为\(index1)当前的内容为\(item1)",index1,item1))
}

>定义字典

//第一种写法
var dict : Dictionary<String,Any> = ["name":"jack"];//注意如果values不确定类型的话,直接用Any表示
//第二种写法
var dict1 : [String:Any] = ["name":"jack"];

//创建一个可变字典
var dict2 = [String:Any]()
//添加
dict2["name"] = "jack"
dict2["age"] = "18"
dict2["height"] = "188"
//修改
dict2["name"] = "tom"
//删除
dict2.removeValue(forKey: "name")

for item in dict2.keys {
    print(item)
}


for (key,value) in dict2 {
    let st = String(format: "这里的key=\(key),这里的value=\(value)",key,value as! String)//注意:由于写的是Any,表示任意类型,所以这一步需要转换,//as! String    表示转化为String 类型
    print(st)
}

>关于元组元组类似于OC中的数组,字典

//第一种写法  可以通过位置角标直接取值
let y = ("name","man","188");
y.0
y.1
y.2

//第二种写法  可以通过对应的key 直接取出相对应的值,一般使用这种
let x = (name: "name",age:"18")
x.age
x.name

//第三种写法
let (name,age) = ("name","18");

>关于可选类型 在OC开发中,如果一个变量暂时不适用,可以直接赋值为0,或者赋值为空 在Swift开发中nil也是一个特殊的类型,不能将一个暂时不使用的变量赋值为nil,可以利用Optional或者?来代替

//var s : String = nil //错误写法
//第一种可选类型的写法

var s : Optional<String> = nil //初始化为nil
s = Optional("name") //赋值
print(s!)//取值的时候,后面加上!,为了解析内容

//第二种写法
var y : String? = nil
y = "jack"
print(y!)


//需要注意的是加上!来解析,倘若指还是nil的话,解析会报错
if(y != nil){//多加一层判断
    print(y!)
}

if let y = y {//利用可选绑定(推荐使用)
    print(y)
}

let s : String = "123"
let a : Int? = Int(s)// 表示里面转换有可能为nil,所以类型是个可选类型
print(a!)//打印结果是Optional(123)


let url = URL(string: "www.baidu.com")//也是可选类型,可以长按option+鼠标左键点击url,可以查看类型
if let url = url {
    print(url.absoluteString)
}


let dict : [String:Any] = ["name":"jack","age":18]
let name = dict["name"]//长按option+鼠标左键点击url,可以查看类型为Any? 也就是说有可能中间name没有在整个字典中

//结论 只要一个类型有可能为nil,那么这个标识符的类型一定是一个可选类型

>关于类型转换 as as? as! ??

let s = "123"
(s as NSString).length //as 表示将s转化为NSString类型

let dict : [String:Any] = ["name": "jack","age" : 18]
//as?表示转化可选类型
let name = dict["name"] as? String //第一种写法

if let name = dict["name"] as? String {//第二种写法
    print(name)
}

//as! 表示转化为具体的类型,如果转化不成功,系统将会直接崩溃,一般情况不使用
let name1 = dict["name"] as! String
print(name1)

//?? 下面的语句表示如果a有值,就赋值给i,如果没有值就拿?? 后面的值赋值给i

var i = Int(a) ?? 0

>函数使用

//1.没有参数,没有返回值
func test(){
    print("nihao ")
}

test()


//2.有参数 没有返回值
func test1(name:String){
    print(name)
}

test1(name: "jack")

//3.没有参数,有返回值
func test2() -> String{
    print("没有参数,有返回值")
    return "哈哈"
}

print(test2())

//4,有参数,有返回值
func test3(name:String) -> String{
    return name
}

print(test3(name: "jakctang"))

func test(name : String,age:Int){
    print(name)
}

>关于函数参数的使用

//调用
test(name: "jack",age: 12)
//如果想修改外部name的名字,直接在前面加上名字即可
func test1(name1 name : String,age:Int){
    print(name)
}
test1(name1: "jack",age: 12);//调用名称就变为name1

//如果要隐藏名称,直接在name前面加上下划线,可以直接将name名称隐藏掉
func test2(_ name : String,age : Int){
  print(name)
}

test2("jack",age: 12)

//可变参数,比如如果要打印0-100所以的数字,后面加三个点
func test3(number : Int ...){
    print(number)
}
test3(number: 1,2,3,4,5,6)

>函数传入参数可以自动写入默认

//在类型后面加上=值,表示调用此方法如果不传值,就是用=后面的值
func test(name:String = "jack"){
    print(name)
}
test(name: "tang")
test()

//指针参数  在类型前面加上inout 即可
var m = 20
var n = 10

func test2(num1 : inout Int,num2 : inout Int){
        let temp = num1
        num1 = num2
        num2 = temp
}

test2(num1: &m,num2: &n)

print("m:\(m) n:\(n)")

>枚举类型

//记着添加类型,不然是无法赋值的
enum EnumType : String{
    case NumBerType = "number"
     case IntType = "int"
}

//第二种定义方法
enum EnumType1 : String{
    case NumBerType,IntType
}

>关于结构体,前面用struct来修饰

struct  JackDemo{
    var name : String = "jack"
    
    mutating func changgeName(n:String) {//如果要修改里面的成员属性,必须在前面添加mutating
        name = n;
    }
    
}

var jack : JackDemo = JackDemo(name: "name")//结构体会自动创建几个关于变量的函数,如果要重新构造函数
var jac : JackDemo = JackDemo()

print(jack.name)
print(jac.name)

>类的基本使用

class Demo : NSObject{
    //如果属性是值类型,则初始化为空值
    //如果属性是对象类型,则初始化为nil值
    var name : String = ""
    var age : Int = 0 {  // willSet和didSet 监听属性改变
        willSet{
           
        }
        
        didSet{
        }
    }
    static var view : UIView? //通过类名进行访问
    
    override init(){//系统会默认创建此构造方法,如果自定构造函数,会覆盖次方法,除非重写
        
    }
}

var demo : Demo = Demo()



//调用setValuesForKeys 前提是必须继承NSObject  重写super.init()  为了防止有多余的key或者报错重新 forUndefinedKey
class Person : NSObject{

    var name : String = ""
    var  age : Int = 0
    
    init(dict : [String : Any]) {//字典
//        if let name = dict["name"] as? String{
//            self.name = name;
//        }
        super.init()//必须重洗super.init()
        setValuesForKeys(dict) //使用字典
    }
    
    override func setValue(_ value: Any?,forUndefinedKey key: String) {}//重写forUndefinedKey
    
    
    
    deinit {//监听对象的销毁
        
    }
}


//可选列
class Person{
    var b :Book?
}
class Book{
    var n : Name?
}
class Name{
    var s : String = "名字"
}

let p = Person()
let b = Book()
let n = Name()
 n.s = "hah"
p.b = b
b.n = n

if let name = p.b?.n?.s {//取值操作
    print(name)
}

>protocol 来修饰一个协议,协议名称后注明给class来遵守,默认情况下,必须实现

@objc protocol onclick : class{
  @objc optional func test()
   func test1()
}

class Person : onclick{//遵守协议,默认情况,必选全部实现方法,如果想要可选实现的话,必须在类名和方法名字前面加上 @objc optional
    
    func test() {
        
    }
    
    func test1() {
        
        
    }
    
}


class Person {
    weak var deletse : onclick? //可以让继承者遵守,属性最好用weak,防止循环
    
    func test() {
        deletse?.test()
    }
    
    func test1() {
        
        
    }
}

>懒加载(关于懒加载的两种写法)

lazy var names : [String] = ["jack","tom"]
    
    lazy var nbookName : [String] = { (推荐使用)
        let nbname = ["ehy","assa"]
        return nbname
    }()
    
    
    //懒加载一个控件,并且设置属性
    lazy var btn : UIButton = {
        let  btn = UIButton()
         btn.setTitle("按钮",for: .normal)
        return btn
    }()

>Swift的权限访问 >internal : 内部 (默认情况所有都是internal,在本项目中就可以访问) >private : 私有的只有在本类中访问 >open : 公开的可以在别的项目中也可以访问(就是说在别的包中也可以访问,例如UIButton是一个控件,在别的包中) >fileprivate : 同一个文件中

Swift学习笔记

猜你在找的Swift相关文章