swift学习入门笔记1

mport UIKit

//Swift里不会自动给变量赋初始值，也就是说变量不会有默认值，所以要求使用变量之前必须要对其初始化

var  string:String  报错

加❓时表示可选，实际是这个函数搞得鬼，Optional其实是个enum，里面有None和Some两种类型。其实所谓的nil就是Optional.None, 非nil就是Optional.Some, 然后会通过Some(T)包装（wrap）原始值，这也是为什么在使用Optional的时候要拆包（从enum里取出来原始值）的原因, 也是PlayGround会把Optional值显示为类似{Some "hello world"}的原因，这里是enum Optional的定义：

enum Optional<T> : LogicValue, Reflectable {

    case None

    case Some(T)

    init()

    init(_ some: T)

    /// Allow use in a Boolean context.

    func getLogicValue() -> Bool

    /// Haskell's fmap, which was mis-named

    func map<U>(f: (T) -> U) -> U?

    func getMirror() -> Mirror

}

var strValue: Optional<String>

var strValue:?      //一样的效果

 ／／表示我声明了一个Optional类型值，它可能包含一个String值，也可能什么都不包含

strvalue?.hashvalue

strValue是Optional的字符串，如果strValue是nil，则hashValue也为nil，如果strValue不为nil，hashValue就是strValue字符串的哈希值(其实也是用Optional wrap后的值)

另外，?还可以用在安全地调用protocol类型方法上

self.delegate?fun

//as转换的时候 let dataSource = object as? Circle

//解拆包这个过程应该类似java的调用个人理解估计是加了一些其他的控制、

不像java那样一直可以点

现在知道?的几种使用场景:

1.声明Optional值变量

2.用在对Optional值操作中，用来判断是否能响应后面的操作

3.用于安全调用protocol的optional方法

4.使用 as? 转型

有时又会遇到！

表示什么鬼呢，按刚才?的解释那么这里表示非

对，就是这个意思我确定这里一定是非nil的随便你调用后面的

self.circle!.print()

!的使用情境

1.强制对Optional值进行拆包(unwrap)

2.声明Implicitly Unwrapped Optionals值，一般用于类中的属性

//常量与变量的区别

var  my=42

my=56

let  you=78

//you=23不合法

let  s:Double=78.9

var str="hhah"

str="yes"

let  st="dad"

str=st

let  yous="\(s)"+"\(str)\(s)"

//数组

var  array=["qu","nami","wan"]

let  ss:String=array[0]

var  emp=[String]()

emp=["asd","asda","asdas"]

for ss1  in  emp{

 print(ss1+"\n")

}

var op:String?="hello"

var si:String?=nil

func greet(name:String ,day:String)->String

{

    return "\(day)"+"sda"

}

greet("asd", day: "2013")

//返回多个参数，使用一个变量接收  实现估计跟数组时差不多的

func  caculatorstatics(scores:[Int])->(min:Int,max:Int,sum:Int)

{

    var  min=scores[0]

    var  max=scores[0]

    var  sum=0

    for  score  in  scores{

        if  score<min{

            min=score

        }

        else  if  score>max

        

        {

            max=score

            

        }

        sum+=score

    }

    return  (min,max,sum)

}

let  sd=caculatorstatics([6,9,4,3,2])

print(sd.2)
//不限参数的调用

func  sumof(numbers:Int...)->Int

{

    var   s=0;

    for number  in  numbers

    {

        s+=number;

    }

    return s

}

let   re=sumof(9,7,6,3)

//大体不知道什么情况下用

func  makeincrement()->((Int)->Int)

{

    var  stm="hhhh"

    func    addone(number:Int)->Int

    {

     

        print("我第一次来时hhh")

        return 1+number;

    }

    stm="看我变了"

    print(stm)

    return   addone

    

}

var  ere=makeincrement()

print(ere(7))

func  isshuzi(legle:Int)->Bool

{

   return  legle<3

}

//写函数时 可以将函数作为参数传入

func  hasanymatches(list:[Int],condition:(Int)->Bool)->Bool

{

    

    for item in list

    {

        if  condition(item)

        {    return  true;

    

        }

    }

    return false;

}

hasanymatches([2,4,6], condition:isshuzi)

//可以将数组的东西依次做完变化，返回新的数组

var  numberq=[1,2,3,0]

var  anumber=[4];

numberq+=anumber

numberq.map({

    (number:Int)->Int in

    let  result=3*number;

    return  result;

})

//数组排序

let    sortenumbers=numberq.sort{$0>$1}

print(sortenumbers)

class Shape {

    var   numberofsides=0;

  func    simpledescrip()->String

  {

    return  "i  ma  shape"

    }

}

var   shape=Shape()

print("\(Shape.simpledescrip)")

class   Circle

{

    var  radius:Double?

    

    init(radius:Double)

    {

        if radius>0{

        self.radius=radius

        }

        else

        {

            self.radius?=0;

        }

    }

    

}

var  cir=Circle(radius: 67);

//继承

class realcir: Circle {

    

    var  name:String?

    

    init(name:String,radius:Double)

    {

        super.init(radius:radius);

        self.name=name;

        

    }

    var   circle:Circle?;

    

}

//枚举类型

enum  Rank:Int

{

    case  low=1;

    case  mid=2;

    case  high=3;

    case  hard,final

    func  rankstring()->String

    {

        switch self

        {

        case.low:  return  "简单"

        case.mid:  return "普通"

        case.hard:  return "困难"

        case.final:  return  "究极"

        default:

            return    "困难"

        }

    }

}

var    ra=Rank.low;

var    strins=ra.rankstring()

//use protocol  的例子

protocol  findpro

{

    func  findahouse(name:String)

}

class Person {

    var   name="wo";

    var   delegate:findpro?

   

   

    func  gofin()

    {

        self.delegate!.findahouse(self.name)

    }

    

    

}

class Agent:findpro

{

    var   name="agent"

    func  findahouse(name: String) {

        print("\(self.name)"+"给"+"\(name)"+"找到房子了")

        

    }

}

var  perso=Person()

var   age=Agent()

perso.delegate=age

perso.gofin()

//扩展

extension  String

{

//    func  reChare(str:String)->String

//    {

//        return   str.uppercaseString

//    }

    //使用静态方法和不是静态方法的区别

    static func  reChare(str:String)->String

    {

        return   str.uppercaseString

    }

}

var  newstr=String()

var   newstr1=String.reChare(str)

//var  sssss=newstr.reChare(str)

print(newstr1)

//自定义异常类

enum  mycustom:ErrorType

{

    case  kongzh,buhefa

    case   ilegle

    

}

class errw {

    

     init ( setmyname:String) throws

    {

        if  setmyname.characters.count==0{

       

            throw   mycustom.ilegle

            

        }

    }

}

//在函数返回之前，使用延迟写一段代码，在函数中的所有其他代码后执行。该代码是执行的，不管该函数是否抛出错误。您可以使用延迟写设置和清理代码，即使它们需要在不同的时间执行。这里模拟了一个情景，将一个东西添进数组时

var   i=0;

var   isopen=false;

var   alist=["1","23","4","5"]

func  fridgeContent(str:String)->Bool

{

    isopen=true

    defer

    {

      isopen=false;

    }

    return alist.contains(str)

}

fridgeContent("7")

//泛型的使用,一次性添加几个相同的对象到范型数组

func  prin<Circle>(mlist:Circle ,numberofcir:Int)->[Circle]

{

    var   ane=[Circle]()

    

    for  _  in  0..<numberofcir{

        ane.append(mlist)

    }

    return  ane

    

}

var     circles=prin(cir, numberofcir: 4)

circles.count

// 枚举,这样写首先你会觉得很奇怪但是语言不就本是抽象的么，因此没什么大不了的

enum  optionalvalue<Circle>

{

    case  one

    case some(Circle),arc

    

}

var  pa:optionalvalue<Circle>=.one

var  pa1:optionalvalue<Circle>=.some(cir)

//在类型名后面使用where来指定对类型的需求，比如，限定类型实现某一个协议，限定两个类型是相同的，或者限定某个类必须有一个特定的父类。

func anyCommonElements <T: SequenceType, U: SequenceType where T.Generator.Element: Equatable, T.Generator.Element == U.Generator.Element> (one: T,_ two: U) -> Bool {

    for lhsItem in one {

        for rhsItem in two {

            if lhsItem == rhsItem {

                return true

            }

        }

    }

    return false

}

anyCommonElements([1, 2, 3], ["hh"])

//循环引用的效果

class one

{

    let t:two

    init()

    {

        t=two()

        t.a=self

        

    }

    deinit

    {

        

        print("one  deinit")

    }

}

class two {

    var   a:one?=nil

    deinit

    {

        print("two  deinit")

    }

}

var   aone:one?=one()

var   tt:two?=two()

tt!.a=aone

tt!.a=nil

tt=nil

aone=nil
这里注意aone始终不会掉用析购函数引用循环