Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Swift notes - let you two hours to learn Swift     - Use IF NOT EXISTS create a data table (Database)

- Java Adapter Mode (Programming)

- Java regular expression syntax (Programming)

- Linux, MySQL root privilege escalation another method (Linux)

- Oracle SQL statement to retrieve data paging table (Database)

- Use MD5 transform algorithm to prevent exhaustive decipher passwords (Linux)

- Linux can modify the maximum number of open files (Linux)

- Linux modify the system time (Linux)

- Questions about Linux compiler u-boot (Programming)

- Linux - use chroot command (Linux)

- MySQL import large amounts of data (Database)

- C ++ input and output summary _ Input (Programming)

- Bash command substitution (Programming)

- Ubuntu how to install and use Objective-C (Linux)

- How to Debian Linux the default Python version switch to alternative version (Linux)

- C ++ function object (Programming)

- Ubuntu Live CD by updating Grub resume boot the Boot Menu (Linux)

- CentOS 6.5 makes the LAN http source (Linux)

- Nginx Installation and Configuration (Server)

- Python pickle module for simple use notes (Programming)

 
         
  Swift notes - let you two hours to learn Swift
     
  Add Date : 2018-11-21      
         
         
         
  While learning Swift, while writing notes, we believe that under certain circumstances based on other languages ​​1.5 hours to master reading the article. Then spend 30 minutes to open the XCode write a Demo. Life took two hours to understand a language, it is worth it!

Notes divided into two parts, a basic knowledge of Swift, the second use Xcode to develop a software
[TOC]

swift Basics

Variables and constants

// Define the variable
var myVariable = 123

// Define constants
let myConstantVariable = 123

// Implicitly specified integer type
var anInteger = 2

// Explicitly specify the integer type
let anExplicitInteger: Int = 2
Tuple

let aTuple = (1, "Yes")
let anotherTuple = (aNumber: 1, aString: "Yes")
let theOtherNumber = anotherTuple.aNumber // = 1
Other Uses

let http404Error = (404, "Not Found")
let (statusCode, statusMessage) = http404Error
print ( "The status code is (statusCode)")
More user function return values, the return value of more than two, like with golang

Array

var arrayOfIntegers: [Int] = [1,2,3]
// Implicitly designated
var implicitArrayOfIntegers = [1,2,3]

// You can also create an empty array, but must provide their type
let anotherArray = [Int] ()

// Function using the append append to the end of the array of objects
myArray.append (4)

Anywhere in the array // insert objects
myArray.insert (5, atIndex: 0)


dictionary

A dictionary is an array type that maps keys to values ​​similar to Java's Map, PHP's

 var crew = [
          "Caption": "Jean-Luc Picard",
          "First officer": "William Riker",
          "Second Officer": "Data"
];


crew [ "Captain"]
// = "Jean-Luc Picard"
Control flow

if

 if 1 + 1 == 2 {
         println ( "The math checks out")
}
for-in

let loopingArray = [1,2,3,4,5]
var loopSum = 0
for number in loopingArray {
     loopSum + = number
}
loopSum // = 15

var firstCounter = 0
     for index in 1 .. <10 {
         firstCounter ++
     }
// Loop 9

var secondCounter = 0
for index in 1 ... 10 {// note the three dots, not two
         secondCounter ++
     }
// 10 cycles

var sum = 0
for var i = 0; i <3; i ++ {
    sum + = 1
}
sum // = 3
while

var countDown = 5
while countDown> 0 {
     countDown--
}
countDown // = 0
var countUP = 0
do {
         countUp ++
} While countUp <5
countUp // = 5
if-let

You can use if-let statement checks whether the variable contains an optional value. If included, the specified value to a constant variable, and then run a section of code. This can reduce many lines of code, but also to ensure safety

var conditionalString:? String = "a string"
     if let theString = conditionalString? {
         println ( "The string is ' (theString)'")
     } Else {
         println ( "The string is nil")
}
// Prints "The string is 'a string'"
function

Single simple function return value

Two parameters, a return value, both for the Int

func thirdFunction (firstValue: Int, secondValue: Int) -> Int {
         return firstValue + secondValue
     }
thirdFunction (1, 2)
Multi-tuple return value

func fourthFunction (firstValue: Int, secondValue: Int)
         -> (Doubled: Int, quadrupled: Int) {
         return (firstValue * 2, secondValue * 4)
     }
fourthFunction (2, 4)

// Use Digital Access:
fourthFunction (2, 4) .1 // = 16

// Otherwise identical, except that the name:
fourthFunction (2, 4) .quadrupled // = 16

External Name calling

When you define a function, you can specify the name as a parameter. When I could not understand the purpose of each parameter immediately, this feature will be very useful. It can be used to define the parameter names as follows:

func addNumbers (firstNumber num1: Int, toSecondNumber num2: Int) -> Int {
         return num1 + num2
}
addNumbers (firstNumber: 2, toSecondNumber: 3) // = 5

When you create a name for the parameter name is to create an internal and an external parameter name, the name of an internal and external parameters should be the same name. Will enter the same name twice no problem, but it does have an easy way to define the internal name of an external parameter name the same - that is, before the parameter name put a # symbol

func multiplyNumbers (#firstNumber: Int, #multiplier: Int) -> Int {
         return firstNumber * multiplier
}
multiplyNumbers (firstNumber: 2, multiplier: 3) // = 6
Function as a variable

var numbersFunc: (Int, Int) -> Int;
// NumbersFunc can now store accepts any two Int and returns an Int function

numbersFunc = addNumbers
numbersFunc (2, 3) // = 5
Closure closure

sort we need to pass a closure as a parameter

var numbers = [2,4,34,6,33,1,67,20]
var numbersSorted = numbers.sort ({(first, second) -> Bool in
    
    return first })
Closures contain only one line of code, you can omit the return keyword

var numbersSorted = numbers.sort ({$ 1> $ 0})
print (numbersSorted)
If a closure is a function call in the last parameter, which can be placed outside the brackets. This is purely to improve readability, the closure does not change the way of working

var numbersSorted = numbers.sort () {$ 1> $ 0}
print (numbersSorted)
Closure on the variables inside

var comparator = {(a: Int, b: Int) in a comparator (1, 2) // = true

Objects

definition

class Vehicle {
    var color: String?
    var maxSpeed ​​= 80
    func description () -> String {
        return "A (self.color) vehicle"
    }
    func travel () {
        print ( "Traveling at (maxSpeed) kph")
    }
}
use

var redVehicle = Vehicle ()
redVehicle.color = "Red"
redVehicle.maxSpeed ​​= 90
redVehicle.travel () // output "Traveling at 90 kph" redVehicle.description () // = "A Red vehicle"
inherit

To override a function, to re-declare it in a subclass, and add the override keyword

class Car: Vehicle {
// Derived class can override function
             override func description () -> String {
                 var description = super.description ()
                 return description + ", which is a car"
}}
In a rewritten function, which can be super callback function in the parent class version

override func description () -> String {
         var description = super.description ()
         return description + ", which is a car"
}
Initialization and deinitialization


class InitAndDeinitExample {
    // Specified initializers (that is, the primary initializer)
    init () {
        print ( "I've been created!")
    }
    // Initialize the device easily, by calling the designated initializer required
    convenience init (text: String) {
        self.init () // This is required
        print ( "I was called with the convenience initializer!")
    }
    // Anti-initializer
    deinit {
        print ( "I'm going away!")
    }
}

var example: InitAndDeinitExample?
// Initialize the specified device
example = InitAndDeinitExample () // output "I've been created!"
example = nil // output "I'm going away"
// Initialize the device easy to use
example = InitAndDeinitExample (text: "Hello")
// Prints "I've been created!"
// Then output "I was called with the convenience initializer"
When you create a device initialization can return nil (also known as device initialization can fail), we put a question mark behind the init keyword and initialize the device determines that it can not successfully construct the object, use the return nil:

convenience init (value: Int)? {
    self.init ()
    if value> 5 {
        // Can not initialize the object; returns nil, return nil indicates initialization failure
    }}
When using a variable initialization device can fail, the results can be stored in any which are optional:

let failableExample = InitAndDeinitExample (value: 6)
// = Nil
protocol

The benefit of using the protocol that can be used Swift's type system to reference any object comply with a given agreement, individuals are now understood to be Interface concept.

protocol Blinking {
    var isBlinking: Bool {get}
    var blinkSpeed: Double {get set}
    func startBlinking (blinkSpeed: Double) -> Void
    
}

class Light: Blinking {
    var isBlinking = false
    var blinkSpeed ​​= 1.2
    func startBlinking (blinkSpeed: Double) {
            print ( "now my speed is (self.blinkSpeed)")
    }
    
}
Spread

 extension Int {
         var doubled: Int {
             return self * 2
         }
         func multiplyWith (anotherNumber: Int) -> Int {
             return self * anotherNumber
}}

2.doubled // = 4
4.multiplyWith (32) // = 128
You can also use the extension to make a type of a compliance agreement

extension Int: Blinking {
    var isBlinking: Bool {
        return false;
    }
    var blinkSpeed: Double {
        get {
            return 0.0;}
        set {
            // Do nothing
        }}
    func startBlinking (blinkSpeed: Double) {
        print ( "I am the integer (self). I do not blink.")
    }}
2.isBlinking // = false
2.startBlinking (2.0) // output "I am the integer 2. I do not blink."
Access control

When a method or property declared as public, App to everyone can see it:

// Available for all to access
public var publicProperty = 123

// If a method or property declared as private, it can only be declared in its internal source files to see it:
// Can only be accessed in the source file
private var privateProperty = 123

// Only access for this module
// Here 'internal' is the default and can be omitted
internal var internalProperty = 123
Operator Overloading

Similar to C ++ operator overloading

class Vector2D {
    var x: Float = 0.0
    var y: Float = 0.0
    init (x: Float, y: Float) {
        self.x = x
        self.y = y
    }
   
}
func + (left: Vector2D, right: Vector2D) -> Vector2D {
    let result = Vector2D (x: left.x + right.x, y: left.y + right.y)
    return result
}

let first = Vector2D (x: 2, y: 2)
let second = Vector2D (x: 4, y: 1)
let result = first + second
Generics

Swift and Java generics same

class Tree {
    // 'T' can now be used as a type var value: T
    var value: T
    var children: [Tree ] = []
    init (value: T) {
        self.value = value
    }
    func addChild (value: T) -> Tree {
        var newChild = Tree (value: value)
        children.append (newChild)
        reutrn newChild
    }
}


// Integer tree
let integerTree = Tree (value: 5)
// You can increase the subtree contains Int
integerTree.addChild (10)
// Use Swift Designer | 45
integerTree.addChild (5)
// String tree
let stringTree = Tree (value: "Hello")
stringTree.addChild ( "Yes")
stringTree.addChild ( "Internets")
String

Compare strings

  let string1: String = "Hello"
     let string2: String = "Hel" + "lo"
     if string1 == string2 {
         println ( "The strings are equal")
  }
Find String

 if string1.hasPrefix ( "H") {
         println ( "String begins with an H")
     }
     if string1.hasSuffix ( "llo") {
         println ( "String ends in 'llo'")
     }
data

let stringToConvert = "Hello, Swift"
let data = stringToConvert.dataUsingEncoding (NSUTF8StringEncoding)

Swift with cocoa use Xcode development software

Open Xcode 7.2

Open Xcode choose New Project OSX Application

Open Main.storyboard, drag Label in the ViewController

 modify the code ViewController.swift

import Cocoa

class ViewController: NSViewController {

    @IBOutlet Weak var timestamp: NSTextField!
    @IBOutlet Weak var dateLabel: NSTextField!
    @IBAction Func calc (sender: NSButton) {
        
        // Input string to NSString
        let string = NSString (string: self.timestamp.stringValue)
        
        // Switch to double type
        let ts: NSTimeInterval = string.doubleValue
        
        // Conversion Date
        let date = NSDate (timeIntervalSince1970: ts)
        
        // Date format
        let dfmatter = NSDateFormatter ()
        dfmatter.dateFormat = "yyyy Year MM month dd day"
        
        // Display the Label
        dateLabel.stringValue = dfmatter.stringFromDate (date)
    }
    override func viewDidLoad () {
        super.viewDidLoad ()

        // Do any additional setup after loading the view.
    }

    override var representedObject: AnyObject {
        didSet {
        // Update the view, if already loaded.
        }
    }


}

NSTextField exclamation mark behind the above, it is called optional type implicit unpacking, is a special type, there may be noted that the value of the variable, or may be nil. Swift does not like to visit the operating environment variable is nil, therefore Swift programmer must be aware of the values ​​of variables, especially when it may be nil.

Declare a variable implicitly opened optional type corresponds tell Swift compiler, you must promise not to access it at the value of the variable is nil. This is a contract that you signed with the compiler, you must comply. If you do not comply, the variable is nil when accessing it, will lead to the operational phase errors cause the application to stop running.
     
         
         
         
  More:      
 
- Two kinds of agents of Spring AOP (Programming)
- Use the dd command to the hard disk I / O performance test (Linux)
- xCAT line installation on CentOS 6.X (Linux)
- C ++ Object Model Comments (Programming)
- Using Oracle for Oracle GoldenGate to achieve a one-way data synchronization (Database)
- Use window.name + iframe cross-domain access to data Detailed (Programming)
- Getting Started with Linux: Nginx Web Server How to Block Specific User Agents (UA) (Server)
- How to modify the Sublime in Tab four spaces (Linux)
- Oracle ordinary users show parameter method (Database)
- Use PuTTY to access the virtual machine Linux under Windows xp (Programming)
- Compile and install LNMP under CentOS 6.5 (Server)
- Java Timer (regular calling, to achieve a fixed time to perform) (Programming)
- Single list summarizes the basic operation (Programming)
- CentOS6.x and Windows XP and Windows Server 2003 Open IPv6 related matters (Linux)
- CentOS 7 update source - the use of domestic sources 163 yum (Linux)
- MySQL Installation Troubleshooting (Database)
- Linux Operating System Security Study (Linux)
- Quagga use authentication on strengthening BGP session security (Linux)
- Beautiful start Ubuntu installation tool Duck Launcher 0.64.5 (Linux)
- Java class loading order (Programming)
     
           
     
  CopyRight 2002-2022 newfreesoft.com, All Rights Reserved.