Trouver la somme des éléments dans un tableau Swift

Swift 3 / Swift 4 un liner à la somme des propriétés des objets

var totalSum = scaleData.map({$0.points}).reduce(0, +)

Où points est la propriété de mon objet personnalisé scaleData, que je suis en train de réduire

Swift3 a changé pour:

let multiples = [...]
sum = multiples.reduce(0, +)

Cela fonctionne aussi:

let arr = [1,2,3,4,5,6,7,8,9,10]
var sumedArr = arr.reduce(0, combine: {$0 + $1})
print(sumedArr)

, Le résultat sera: 55

Que diriez - vous de la manière simple de

for (var i = 0; i < n; i++) {
 sum = sum + Int(multiples[i])!
}

//où n = nombre d'éléments dans le tableau

Swift 3

Si vous avez un tableau d'objets génériques et que vous voulez additionner une propriété d'objet, alors:

class A: NSObject {
    var value = 0
    init(value: Int) {
       self.value = value
    }
}

let array = [A(value: 2), A(value: 4)]      
let sum = array.reduce(0, { $0 + $1.value })
//                           ^       ^
//                        $0=result  $1=next A object
print(sum) // 6 

Malgré la forme plus courte, plusieurs fois vous pouvez préférer le classique for-cycle:

let array = [A(value: 2), A(value: 4)]
var sum = 0
array.forEach({ sum += $0.value}) 
// or
for element in array {
   sum += element.value
}

Exemple Swift 4

class Employee {
    var salary: Int =  0
    init (_ salary: Int){
        self.salary = salary
    }
}

let employees = [Employee(100),Employee(300),Employee(600)]
var sumSalary = employees.reduce(0, {$0 + $1.salary}) //1000

Une solution possible: définissez un opérateur de préfixe pour cela. Comme l'opérateur reduce "+ / " comme dans APL (par exemple GNU APL)

Une approche un peu différente ici.

L'utilisation d'un protocole en type générique nous permet d'utiliser cet opérateur sur les types de tableaux Double, Float et Int

protocol Number 
{
   func +(l: Self, r: Self) -> Self
   func -(l: Self, r: Self) -> Self
   func >(l: Self, r: Self) -> Bool
   func <(l: Self, r: Self) -> Bool
}

extension Double : Number {}
extension Float  : Number {}
extension Int    : Number {}

infix operator += {}

func += <T:Number> (inout left: T, right: T)
{
   left = left + right
}

prefix operator +/ {}

prefix func +/ <T:Number>(ar:[T]?) -> T?
{
    switch true
    {
    case ar == nil:
        return nil

    case ar!.isEmpty:
        return nil

    default:
        var result = ar![0]
        for n in 1..<ar!.count
        {
            result += ar![n]
        }
        return result
   }
}

Utiliser comme ceci:

let nmbrs = [ 12.4, 35.6, 456.65, 43.45 ]
let intarr = [1, 34, 23, 54, 56, -67, 0, 44]

+/nmbrs     // 548.1
+/intarr    // 145

(mis à jour pour Swift 2.2, testé dans Xcode version 7.3)

Swift 3.0

J'ai eu le même problème, j'ai trouvé sur la documentation Apple Cette solution.

let numbers = [1, 2, 3, 4]
let addTwo: (Int, Int) -> Int = { x, y in x + y }
let numberSum = numbers.reduce(0, addTwo)
// 'numberSum' == 10

Mais, dans mon cas, j'avais une liste d'objet, alors j'ai besoin de transformer ma valeur de ma liste:

let numberSum = self.list.map({$0.number_here}).reduce(0, { x, y in x + y })

Ce travail pour moi.

Dans Swift 4 Vous pouvez également étendre le type numérique de retourner la somme de tous les éléments de la collection comme suit

extension Collection where Element: Numeric {
    /// Returns the sum of all elements in the collection
    func sum() -> Element { return reduce(0, +) }
}

let numbers = [1,2,3]
numbers.sum()    // 6

let doubles = [1.5, 2.7, 3.0]
doubles.sum()    // 7.2

@IBOutlet var valueSource: [MultipleIntBoundSource]!

private var allFieldsCount: Int {
    var sum = 0
    valueSource.forEach { sum += $0.count }
    return sum
}

Utilisé celui-ci pour les paramètres imbriqués

Swift 3

De toutes les options affichées ici, c'est celle qui a fonctionné pour moi.

let arr = [6,1,2,3,4,10,11]


var sumedArr = arr.reduce(0, { ($0 + $1)})
print(sumedArr)

Pour la somme des éléments dans un tableau d'objets

self.rankDataModelArray.flatMap{$0.count}.reduce(0, +)

Reste simple...

var array = [1, 2, 3, 4, 5, 6, 7, 9, 0]
var n = 0
for i in array {
    n += i
}
print("My sum of elements is: \(n)")

Sortie:

MA somme d'éléments est: 37

C'est mon approche à ce sujet. cependant, je crois que la meilleure solution est la réponse de l'utilisateur nom d'utilisateur à déterminer

var i = 0 
var sum = 0
let example = 0
for elements in multiples{
    i = i + 1
    sum = multiples[ (i- 1)]
    example = sum + example
}