Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Swift notes - let you two hours to learn Swift     - FileZilla FTP && TLS connection settings of (Linux)

- Oracle PL / SQL selective basis (IF CASE), (LOOP WHILE FOR) (Database)

- ssh port forwarding Comments (Server)

- I like Linux Security (Linux)

- Linux system started to learn: Teaches you install Fedora 22 on VirtualBox (Linux)

- iTerm - let your command line can also be colorful (Linux)

- Monitoring network traffic with Iptraf in Linux environment (Linux)

- LVM management parameters commonly used commands explained in detail (Linux)

- Computer security protection remove local and remote system log files (Linux)

- Modify Linux SSH default port 22 in several ways (Linux)

- Oracle restrict certain IP, the malicious user actions on important table (Database)

- An example of troubleshooting of embedded Linux OpenWRT (Linux)

- Linux kernel netpoll framework netconsole (Linux)

- Hibernate4 The Hello World (basic environmental structures) (Programming)

- CentOS achieve trash mechanism (Linux)

- VirtualBox install Windows 8.1 has encountered an error 0x000000C4 solutions (Linux)

- Java to create a table in the database SYBase (Database)

- cursor_sharing induced error ORA-00600 (Database)

- Sorting Algorithm (1) Quick Sort C ++ implementation (Programming)

- Use mysqldump MySQL database backup - Linux Shell Scripting (Database)

 
         
  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:      
 
- Oracle 11g through SCN do incremental backup repair standby library detailed process (Database)
- Python type way of comparison (Programming)
- Digital jQuery scrolling effect (Programming)
- how to quickly find a file on Linux system (Linux)
- Java developers question (Programming)
- Linux kernel RCU (Read Copy Update) lock Brief (Linux)
- Linux mount command Detailed (Linux)
- Linux file permissions bit forced bits and adventure Comments (Linux)
- Linux log management tools Logrotate (Linux)
- Shell programming entry (Programming)
- Sorting Algorithm (1) Quick Sort C ++ implementation (Programming)
- Ten best plug surge Emacs Productivity (Linux)
- Terminal Linux command prints - echo (Linux)
- Zabbix configure DataGuard monitoring (Database)
- CentOS7 compile and install Tengine + PHP + MariaDB notes (Server)
- Installation GitLab appears ruby_block supervise_redis_sleep action run (Linux)
- Linux Getting Started tutorial: GNU C and Vim will fight the C / C ++ IDE semi-automatic (Linux)
- C ++ complex class of operator overloading (Programming)
- Linux performance monitoring (Linux)
- Chkconfig command Detailed service is added and shut down the system in two ways to start service under Linux (Linux)
     
           
     
  CopyRight 2002-2020 newfreesoft.com, All Rights Reserved.