2016-08-12 18:34:37 Lucy_xiao 阅读数 700

初学Swift发现没有宏定义,只有自己制作NSLog了

定义NSLog是希望只在调试的时候输出所以要先设置相应的环境:

debug环境和release环境切换 
点击项目 -Edit Scheme- Run - info - Build Configuration-Debug/Release


自定义NSLog

1、设置DEBUG


2、  在app delegate文件中添加如下代码,添加后则所有控制器都可以使用
#file:获取所在文件的路径
#function:获取所在的方法
 #line:获取所在的行数

    func LMXLog<T>(message : T, file : String = #file, function : String = #function, line : Int = #line)
    {
// 获取打印所在的文件
#if DEBUG
       let fileName = (file as NSString).lastPathComponent
       
        print("(\(fileName)):(\(function)):(\(line))-\(message)")
  #endif
    }






2017-08-01 16:06:41 ajdfhajdkfakr 阅读数 1374

在实际用Swift写CocoaTouch时,发现下面这样写才可以通过编译

var amiteLbl :UILabel?

self.amiteLbl = UILabel(frame:CGRectMake(50,100,200,40))

self.amiteLbl!.text = “I love mixbox”

self.view?.addSubview(self.amiteLbl)

解释:

由于amiteLbl是可选变量,所以可能有值,也可能为nil。

使用self.amiteLbl!是明确声明此时self.amiteLbl里一定有值,无论什么情况都调用后面的.text赋值方法。

而使用self.view?是声明此时并不确定self.view里是否有值,所以只在view有值时调用后面.addSubview方法。

这样做的目的一是让代码更明确, 二是给编译器提供更多线索,在编译时发现更多潜在错误。

Swift显然是一门非常明确,需要开发者先想清楚再编程的语言。

2014-06-07 15:31:12 zhangbuzhangbu 阅读数 655
打印常量/变量值使用 \()
    let apples = 3
    let oranges = 5
    let appleSummary = "I have \(apples) apples."
    let fruitSummary = "I have \(apples + oranges) pieces of fruit."




创建数组或字典,使用[ ]:
    var shoppingList = ["catfish", "water", "tulips", "blue paint"]
    shoppingList[1] = "bottle of water"
    var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
    ]
    occupations["Jayne"] = "Public Relations"




初始化一个空的数组或字典:
    let emptyArray = String[]()
    let emptyDictionary = Dictionary<String, Float>()






2 Control Flow
条件判断 if / switch
循环控制 for-in for  while  do-while
   
 let individualScores = [75, 43, 103, 87, 12]
    var teamScore = 0
    for score in individualScores {
    if score > 50 {
    teamScore += 3
    } else {
    teamScore += 1
    }
    }
    teamScore


switch case
    let vegetable = "red pepper"
    switch vegetable {
    case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
    case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
    case let x where x.hasSuffix("pepper"):
    let vegetableComment = "Is it a spicy \(x)?"
    default:
    let vegetableComment = "Everything tastes good in soup."
    }


for-in
    let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
    ]
    var largest = 0
    for (kind, numbers) in interestingNumbers {
    for number in numbers {
    if number > largest {
    largest = number
    }
    }
    }
    largest


while/do-while
var m = 2
do {
m = m * 2
} while m < 100
m
for 


传统格式:
var secondForLoop = 0
for var i = 0; i < 3; ++i {
secondForLoop += 1
}
secondForLoop
新的格式:
var firstForLoop = 0
for i in 0..3 {
firstForLoop += i
}
firstForLoop


3 Functions and Closures
    函数名(参数1,参数2)->返回类型
 
   func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
    }
    greet("Bob", "Tuesday")



返回多个参数:
   
 func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
    }
    getGasPrices()



可变参数:
  
  func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
    sum += number
    }
    return sum
    }
    sumOf()
    sumOf(42, 597, 12)


函数嵌套:
    func returnFifteen() -> Int {
    var y = 10
    func add() {
    y += 5
    }
    add()
    return y
    }
    returnFifteen()


返回嵌套函数返回值:
 
   func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
    return 1 + number
    }
    return addOne
    }
    var increment = makeIncrementer()
    increment(7)<pre name="code" class="objc">    class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) {
    self.name = name
    }
    func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
    }
    }




用另一个函数作参数:
    func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    for item in list {
    if condition(item) {
    return true
    }
    }
    return false
    }
    func lessThanTen(number: Int) -> Bool {
    return number < 10
    }
    var numbers = [20, 19, 7, 12]
    hasAnyMatches(numbers, lessThanTen)




{}和$的使用
numbers.map({ number in 3 * number })


sort([1, 5, 3, 12, 2]) { $0 > $1 }
4 Objects and Classes
类实现.构造和析构函数 init/deinit
    class NamedShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) {
       self.name = name
       }
    <code class="code-voice">deinit</code>(){}
 
    func simpleDescription() -> String {
          return "A shape with \(numberOfSides) sides."
       }
    }


类使用:
    var shape = Shape()
    shape.numberOfSides = 7
    var shapeDescription = shape.simpleDescription()




类的继承和函数重载:
<pre name="code" class="objc">class EquilateralTriangle: NamedShape {
   var sideLength: Double = 0.0


   子类中初始化需要执行:
   1)设置子类属性值
   2)父类初始化
   3)设置父类属性值
 
  init(sideLength: Double, name: String) {
     self.sideLength = sideLength
     super.init(name: name)
     numberOfSides = 3
  }


  var perimeter: Double {
  get {
    return 3.0 * sideLength
  }
  set {
    sideLength = newValue / 3.0
  }
}


override func simpleDescription() -> String {
    return "An equilateral triagle with sides of length \(sideLength)."
  }
}




预设置 willSet和 didSet
 
willSet {
square.sideLength = newValue.sideLength
}


When working with optional values, you can write ? before operations like methods, properties, and subscripting. If the value before the ? is nil, everything after the ? is ignored and the value of the whole expression is nil. Otherwise, the optional value is unwrapped, and everything after the ? acts on the unwrapped value. In both cases, the value of the whole expression is an optional value.
    let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
    let sideLength = optionalSquare?.sideLength




5 Enumerations and Structures
enum的定义和使用
    enum Rank: Int {
    case Ace = 1
    case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
    case Jack, Queen, King
    func simpleDescription() -> String {
    switch self {
    case .Ace:
    return "ace"
    case .Jack:
    return "jack"
    case .Queen:
    return "queen"
    case .King:
    return "king"
    default:
    return String(self.toRaw())
    }
    }
    }
    let ace = Rank.Ace
    let aceRawValue = ace.toRaw()



enum值和raw值的转换(toRaw和fromRaw)
  
  if let convertedRank = Rank.fromRaw(3) {
    let threeDescription = convertedRank.simpleDescription()
    }




struct 和class的区别:
struct使用的时候是拷贝,class使用的时候是引用。


6 Protocols and Extensions
声明一个protocol
  protocol ExampleProtocol {
    var simpleDescription: String { get }
    mutating func adjust()
    }


协议使用:
   class SimpleClass: ExampleProtocol {
    var simpleDescription: String = "A very simple class."
    var anotherProperty: Int = 69105
    func adjust() {
    simpleDescription += " Now 100% adjusted."
    }
    }
    var a = SimpleClass()
    a.adjust()
    let aDescription = a.simpleDescription
    struct SimpleStructure: ExampleProtocol {
    var simpleDescription: String = "A simple structure"
    mutating func adjust() {
    simpleDescription += " (adjusted)"
    }
    }
    var b = SimpleStructure()
    b.adjust()
    let bDescription = b.simpleDescription
Notice the use of the mutating keyword in the declaration of SimpleStructure to mark a method that modifies the structure.


Use extension to add functionality to an existing type
    extension Int: ExampleProtocol {
    var simpleDescription: String {
    return "The number \(self)"
    }
    mutating func adjust() {
    self += 42
    }
    }
   simpleDescription





7  Generics
参数类型待定:
    func repeat<ItemType>(item: ItemType, times: Int) -> ItemType[] {
    var result = ItemType[]()
    for i in 0..times {
    result += item
    }
    return result
    }
    repeat("knock", 4)


使用where带参数列表:
    func anyCommonElements <T, U where T: Sequence, U: Sequence, T.GeneratorType.Element: Equatable, T.GeneratorType.Element == U.GeneratorType.Element> (lhs: T, rhs: U) -> Bool {
    for lhsItem in lhs {
    for rhsItem in rhs {
    if lhsItem == rhsItem {
    return true
    }
    }
    }
    return false
    }
    anyCommonElements([1, 2, 3], [3])



                                
2015-11-24 17:08:16 ab375251080 阅读数 509

关键词

Swift 反射 Mirror

Representation of the sub-structure and optional "display style" of any arbitrary subject instance.

Describes the parts---such as stored properties, collection elements, tuple elements, or the active enumeration case---that make up a particular instance. May also supply a "display style" property that suggests how this structure might be rendered.
/// A collection of `Child` elements describing the structure of the
/// reflected subject.
public let children: Children

/// Suggests a display style for the reflected subject.
public let displayStyle: Mirror.DisplayStyle?
@warn_unused_result
public func superclassMirror() -> Mirror?

children记录了该object下的变量(注:此处object为广义的定义)
displayStyle表示该object的类型(同上)
superclassMirror,顾名思义,表示其父类的Mirror

public enum DisplayStyle {
        case Struct
        case Class
        case Enum
        case Tuple
        case Optional
        case Collection
        case Dictionary
        case Set
    }

根据displayStyle的类型去判断类型再做分类讨论,其中Optional是Swift中独有比较特别的类型,需要特殊处理,当displayStyle为nil时,表示为基本数据类型

最后通过superclassMirror一层一层递归,去遍历所有变量

func getModel(dic:Dictionary<String, Any>, objName:String) -> MYDataModel {
        let modelClass = NSClassFromString(objName) as! MYDataModel.Type
        model = modelClass.init()
        var mirror:Mirror? = Mirror(reflecting: model)
        while (mirror != nil) {
            traverseProperty(dic, mirror, model)
            mirror = mirror!.superclassMirror()
        }
        return model
    }

private func traverseProperty(dic:Dictionary<String, Any>, _ mirror:Mirror?, _ model:MYDataModel) {
        if (mirror == nil) {
            return
        } else {
            for (_,value) in mirror!.children.enumerate() {
                let propertyName:String = value.label == nil ? "" : value.label!
                let properValue = value.value
                let dictionaryValue = dic[propertyName]
                let tmp = Mirror(reflecting: properValue)
                if (dictionaryValue != nil) {
                    if (tmp.displayStyle != nil) {
                        switch tmp.displayStyle! {
                        case .Class:
                            if let dicValue = dictionaryValue as? [String: String] {
                                let anyClass = model.classForCoder as? NSObject.Type
                                let arrayTypeName = anyClass!.performSelector(Selector("\(propertyName)Type")).takeRetainedValue() as? String
                                let anyArrayClass = NSClassFromString(arrayTypeName!) as! MYDataModel.Type
                                let obj = anyArrayClass.init()
                                traverseProperty(dicValue, Mirror(reflecting: obj), obj)
                                model.setValue(obj, forKey: propertyName)
                            }
                        case .Collection:
                            let anyClass = model.classForCoder as? NSObject.Type
                            let arrayTypeName = anyClass!.performSelector(Selector("\(propertyName)Type")).takeRetainedValue() as? String
                            switch arrayTypeName! {
                            case MYDataModelType.String.rawValue:
                                if let arrayValue =  dictionaryValue as? [String] {
                                    if (arrayValue.count > 0) {
                                        model.setValue(arrayValue, forKey: propertyName)
                                    }
                                }
                            default:
                                if let arrayValue =  dictionaryValue as? [[String: String]] {
                                    var resultArray = [(NSClassFromString(arrayTypeName!) as! MYDataModel.Type).init()]
                                    for item in arrayValue {
                                        let anyArrayClass = NSClassFromString(arrayTypeName!) as! MYDataModel.Type
                                        let obj = anyArrayClass.init()
                                        traverseProperty(item, Mirror(reflecting: obj), obj)
                                        resultArray.append(obj)
                                    }
                                    model.setValue(resultArray, forKey: propertyName)
                                }
                                break
                            }
                        case .Dictionary:
                            print("Dictionary")
                        case .Optional:
                            if (tmp.children.count > 0) {
                                for (_,value2) in tmp.children.enumerate() {
                                    let properValue2 = value2.value
                                    switch properValue2 {
                                    case _ as Bool:
                                        if let boolValue =  dictionaryValue as? Bool {
                                            model.setValue(NSNumber(bool:boolValue), forKey: propertyName)
                                        }
                                    case _ as Int:
                                        if let intValue =  dictionaryValue as? Int {
                                            model.setValue(NSNumber(integer: intValue), forKey: propertyName)
                                        }
                                    case _ as Float :
                                        if let floatValue =  dictionaryValue as? Float {
                                            model.setValue(NSNumber(float: floatValue), forKey: propertyName)
                                        }
                                    case _ as Double :
                                        if let doubleValue =  dictionaryValue as? Double {
                                            model.setValue(NSNumber(double: doubleValue), forKey: propertyName)
                                        }
                                    case _ as String:
                                        if let stringValue =  dictionaryValue as? String {
                                            model.setValue(stringValue, forKey: propertyName)
                                        }
                                    default:
                                        print("\(propertyName) is an unkown optional value")
                                        break
                                    }
                                }
                            } else {
                                print("\(propertyName) is an unkown value")
                                if let objValue =  dictionaryValue as? AnyObject {
                                    model.setValue(objValue, forKey: propertyName)
                                }
                            }
                        default:
                            break
                        }
                    } else {
                        switch properValue {
                        case _ as Bool:
                            if let boolValue =  dictionaryValue as? Bool {
                                model.setValue(NSNumber(bool:boolValue), forKey: propertyName)
                            }
                        case _ as Int:
                            if let intValue =  dictionaryValue as? Int {
                                model.setValue(NSNumber(integer: intValue), forKey: propertyName)
                            }
                        case _ as Float :
                            if let floatValue =  dictionaryValue as? Float {
                                model.setValue(NSNumber(float: floatValue), forKey: propertyName)
                            }
                        case _ as Double :
                            if let doubleValue =  dictionaryValue as? Double {
                                model.setValue(NSNumber(double: doubleValue), forKey: propertyName)
                            }
                        case _ as String:
                            if let stringValue =  dictionaryValue as? String {
                                model.setValue(stringValue, forKey: propertyName)
                            }
                        default:
                            break
                        }
                    }
                }

            }
        }
    }

源码地址:https://github.com/VictorWuSH/SwiftExercise

2015-07-07 11:49:01 soindy 阅读数 3037

     Swift的nil和OC中的nil不一样.在OC中,nil是一个指向不存在对象的指针.而在Swift中,nil不是指针,它是一个不确定的值.用来表示值缺失.任何类型的optional都可以被设置为nil.而在OC中,基本数据类型和结构体是不能被设置为nil的.




   给optional的常量或者变量赋值为nil.来表示他们的值缺失情况.一个optional常量或者变量如果在初始化的时候没有被赋值,他们自动会设置成nil.

Swift整形

阅读数 1824

Swift整形

博文 来自: u012903898

Swift简介

阅读数 132

swift集合

阅读数 1728

Swift生成随机数

博文 来自: evan2916

swift

阅读数 114

没有更多推荐了,返回首页