10 Swift codes that impress Swift program ape

By using a single line of code to do the same 10 exercises, let's take a look at the battle between Swift and other languages.

　　

Multiplies the value of each element in the array by 2

Use map to implement

        var arr = [1,2,3,4];        var newArr = arr.map{$0*2} for        item in NEWARR        {            print (item)        }

The code completes the array element by 2 simply and clearly

To find a set of numbers and

This problem can be solved by using the reduce method and the plus operator, because the plus operator is actually a function. But the solution is very obvious, and later we will see reduce more creative use of the method.

        var arr = [1,2,3,4];                Let sum = arr.reduce (0, combine: +)                print (sum)

Retrieving a string containing a word

We use the Contains method to determine if a string contains at least one of the selected keywords:

        Let arr = [' Forrestwoo ', ' Swift1 '] let        str = ' My name is forrestwoo,i am Learning Swift ' let        query = Arr.contains (s tr.containsstring)        print (query)

Read a file

Let path = Nsbundle.mainbundle (). Pathforresource ("Filter", OfType: "RTF")

Let lines = try? String (contentsoffile:path!). characters.split{$0 = = "\ n"}.map (String.init)

For item in lines! {

Print (item)

}

Happy birthday to you

        Let name = "Forrest"        (1...4). Foreach{print ("Happy Birthday" + (($ = = 3)? " Dear \ (Name) ":" To You ")}

This code will "Happy Birthday to You" song lyrics output to the console, it in a period of time the simple use of map functions, but also used the ternary operator.

Array filtering

Suppose we need to split a sequence (sequence) into two parts using a given filter function. In addition to the regular,, and other functions of many languages, map flatMap reduce filter There is a partitionBy function that can do exactly that. As you know, Swift does not have a similar function (we do not want to use the functions in Nsarray here, and to implement the filtering function through nspredicate ).

So, we can SequenceType solve this problem by expanding and adding partitionBy functions to it. We use this function to split an array of integers into two parts:

Extension sequencetype{    typealias Element = Self.Generator.Element         func partitionby (fu: (Element)->bool)- > ([element],[element]) {        var first=[element] ()        var second=[element] () for El in self        {            if Fu (EL) {                first.append (EL)            } else{                second.append (EL)}}        return (First,second)}} let part    = [82, 58, 76, 49, 88, 90]. Partitionby{$0 < 60}part//([58, 49], [82, 76, 88, 90])

In fact, this is not a single line of code, and the use of a command-style solution. Can you use a slight filter improvement on it?

Extension sequencetype{         func anotherpartitionby (fu: (Self.Generator.Element)->bool) ([ Self.generator.element],[self.generator.element]) {        return (Self.filter (FU), Self.filter ({!fu (+)})}    } Let part2 = [82, 76, 88, 90], 90].anotherpartitionby{$0 < 60}PART2//([58, 49], [+].

The solution was slightly better, but he traversed the sequence two times. And for a single-line code implementation, we removed the closed function, which leads to a lot of duplicate content (filter functions and arrays are used in two places).

Can the original sequence be converted using only a single data stream, and the two parts will be stored in a tuple separately? The answer is yes, how to use reduce :

var part3 = [90].reduce ([],[]), combine: {    (A: ([Int],[int]), N:int), [[Int],[int]    ] in (n<60)? (a.0+[n],a.1): (A.0,a.1+[n]) part3//([58, 49], [82, 76, 88, 90])

Here we create a tuple that holds the results, which contains two parts. The elements in the original sequence are then taken out in turn and placed in the first or second section based on the filtered results.

We finally solved the problem with a real one-line code. One thing to note, though, is that we use append methods to construct two-part arrays, so this is actually a bit slower than the first two implementations.

Get and parse network services in XML format

Some of these languages do not need to rely on external libraries, and there are more than one way to work with XML-formatted data (such as Scala itself can parse XML into objects, although the implementation method is clumsy), but the (Swift) Foundation Library only provides a SAX parser, called N Sxmlparser. You may have guessed it: we're not going to use this.

In this case, we can select some open source libraries. Some of these libraries are implemented in C, some are implemented with OBJECTIVE-C, and there are pure Swift implementations.

This time, we're going to use pure Swift to implement the library: AEXML:

Let xmldoc = try? Aexmldocument (Xmldata:nsdata (Contentsofurl:nsurl (string: "Https://www.ibiblio.org/xml/examples/shakespeare/hen_ V.xml ")!) If let Xmldoc=xmldoc {    var prologue = xmldoc.root.children[6]["Prologue" ["SPEECH"]    prologue.children[1]. StringValue//Now all the youth of England is on fire,    prologue.children[2].stringvalue//And silken dalliance in T He wardrobe lies:    prologue.children[3].stringvalue//Now thrive the armourers, and honour ' s thought    Prologue.children[4].stringvalue//Reigns solely in the breast of every man:    prologue.children[5].stringvalue//The Y sell the pasture now to buy the horse,}

Finds the smallest (or largest) element in the array

There are several ways to find the maximum and minimum values in sequence, one of which is the use minElement and maxElement function:

Find the minimum of an array of Ints[10,-22,753,55,137,-1,-279,1034,77].sort (). first[10,-22,753,55,137,-1,- 279,1034,77].reduce (Int.max, Combine:min) [10,-22,753,55,137,-1,-279,1034,77].minelement ()//Find the maximum of an Array of Ints[10,-22,753,55,137,-1,-279,1034,77].sort (). Last[10,-22,753,55,137,-1,-279,1034,77].reduce (Int.min, Combine:max) [10,-22,753,55,137,-1,-279,1034,77].maxelement ()

　　

Parallel processing

Some languages support parallel processing of sequences in a simple, transparent way, such as using map and flatMap such functions. This uses the underlying thread pool to speed up multiple operations that are executed sequentially but are independent of each other.

Swift does not yet have such a feature, but we can use GCD to achieve:

Http://moreindirection.blogspot.it/2015/07/gcd-and-parallel-collections-in-swift.html

　　

Erato-color-selective sieve method

The ancient and excellent Erato sieve method was used to find all prime numbers less than the given upper limit N.

First, all integers less than n are placed in a sequence (sequence), which removes multiples of each number until all the remaining digits are prime numbers. To speed up execution, we don't actually have to check the multiples of each number, and we can stop when we check the square root of N.

Based on the above definition, the initial implementation might be this:

var n = 50var primes = Set (2...N) (2...Int (sqrt (Double (n))). Foreach{primes.subtractinplace (2*$0). Stride (Through:n, by:$0))}primes.sort ()

In the outer zone, we traverse every number that needs to be checked. For each number, we use the stride(through:Int by:Int) function to calculate the sequence of its multiples. Initially, we constructed a set (set) with all integers from 2 to n, and then subtract the elements from each generated sequence from the collection.

But as you can see, in order to really delete these multiples, we use an externally mutable set, which can cause side effects.

We should always try to eliminate side effects, so we first calculate all the subsequence, then call the flatMap method to expand all of them into a single array, and then remove the integers from the original collection.

var sameprimes = Set (2...N) Sameprimes.subtractinplace ((2...Int (sqrt (Double (n)))                           . flatmap{(2*$0). Stride ( Through:n, By:$0)}) Sameprimes.sort ()

Using destructors to swap values in tuples

Since it is welfare, not everyone knows it. Like other languages that have a tuple type, Swift's tuples can be used to exchange the values of two variables, and the code is simple:

var a=1,b=2 (A, b) = (b,a) a//2b//1

That's all, as we've expected, Swift is as expressive as any other language.

10 Swift codes that impress Swift program ape