Home PC Games Linux Windows Database Network Programming Server Mobile  
           
  Home \ Programming \ Swift notes - let you two hours to learn Swift     - Linux (CentOS) directory file management and file system file compression packing (Linux)

- iOS used in the development --UITabBarController tag controller (Programming)

- Linux user management (Linux)

- Redis master-slave replication switch (Database)

- Unable to solve the official version of Android Studio online update problem (Linux)

- Process monitoring tools Supervisor start MongoDB (Database)

- How do you change the default browser and Email Client in Ubuntu (Linux)

- Oracle 11G using DG Broker create DataGuard (Database)

- Using BBED repair ORA-01190 error (Database)

- CentOS 6.5 install Maven and Nexus warehouse agent (Server)

- MySQL optimization of the relevant Group By (Database)

- Local port forwarding using iptables under linux (Server)

- Java annotations entry automatically generates SQL statements (Programming)

- Ambari and Hadoop configuration, management and monitoring of the project Getting (Server)

- SQL statement to repair SQL Server database (Database)

- Oracle Automatic Diagnostic Repository (Automatic Diagnostic Repository, ADR) (Database)

- C # dynamic class notes --- (Dynamic) Applications (Programming)

- Install MATE desktop environment adjustment tools Mate Tweak 3.3.6 (Linux)

- How Bluetooth turned off by default in Ubuntu 14.04 (Linux)

- Ceph performance optimization summary (v0.94) (Server)

 
         
  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:      
 
- Struts2 configure a static resource files without Struts processing (regular match) (Programming)
- Ubuntu 12.04 commonly use shortcuts finishing Share (Linux)
- Java by Spy Memcached to cache data (Programming)
- linux raid levels and concepts introduced (Linux)
- Vim simple configuration (Linux)
- A step by step teach have to install multi-node cluster configuration Hadoop (Server)
- The strings in Python reside (Programming)
- The security administrator network analysis tools SATAN Introduction under Linux (Linux)
- Linux System Getting Started Learning: Join cron job in Linux (Linux)
- RHEL 5.7 Yum configure local source [Errno 2] No such file or directory (Linux)
- Linux remote landing system (Linux)
- Hadoop2.6.3 build clusters and the development of MapReduce WIN7 by Eclipse on Linux demo (Server)
- Jump table (skiplist) of code (Programming)
- MongoDB Study Notes (1) - Install MongoDB on Windows systems (Database)
- using the ssh command to check the socket / Network Connections (Linux)
- How to use the Linux command compress JPEG images (Linux)
- Elaborate 10-point difference between the new and malloc (Programming)
- Linux kernel modules related to the management Comments (Linux)
- 10 useful Linux command line tips (Linux)
- Ubuntu 12.04 installation DHCP Server (Server)
     
           
     
  CopyRight 2002-2020 newfreesoft.com, All Rights Reserved.