fonction rapide renvoyant un tableau

Im apprentissage rapide et je peux comprendre comment créer une simple fonction qui prend un Tableau et retourne un Tableau. Voilà mon code:

 func myArrayFunc(inputArray:Array) -> Array{

 var newArray = inputArray

//do stuff with newArray

 return newArray
 }

Le rouge d'erreur que je reçois est: Référence générique de type "Array" requiert des arguments dans <>

source d'informationauteur pete

arrays ios swift

27

Dans Swift Array est de type générique, de sorte que vous devez spécifier ce type de tableau. Par exemple:
```
func myArrayFunc(inputArray:Array<Int>) -> Array<Int> {}
```
Si vous voulez que votre fonction générique alors utiliser:
```
func myArrayFunc<T>(inputArray:Array<T>) -> Array<T> {}
```
Si vous ne souhaitez pas spécifier le type ou avoir de la fonction générique utilisation Any type:
```
func myArrayFunc(inputArray:Array<Any>) -> Array<Any> {}
```
8

Dépend de qu'est-ce exactement que vous voulez faire. Si vous voulez une fonction spécialisée qui prend un tableau d'un type spécifique MyType, alors vous pourriez écrire quelque chose comme:
```
func myArrayFunc(inputArray: [MyType]) -> [MyType] {
    //do something to inputArray, perhaps copy it?
}
```
Si vous voulez un générique de la matrice de fonction, alors vous devez utiliser des génériques. Ce serait prendre un tableau de type générique T et retourne un tableau de type générique U:
```
func myGenericArrayFunc<T, U>(inputArray: [T]) -> [U] {

}
```
0

Il n'y a pas une telle chose comme un Array dans Swift, mais il y a des tableaux d'un certain type, vous devez donc vous donner la fonction d'un type générique, comme dans:
```
func myArrayFunc<T>(inputArray:Array<T>) -> Array<T>{  
   //do what you want with the array
}
```
et ensuite l'appeler par l'instanciation de T pour un type spécifique, et le passage d'un tableau de ce type.

0

merci à tous (surtout Kirsteins). Donc, je suis venu avec cet exemple qui fonctionne bien et semble logique:

func myArrayFunc(inputArray:Array<String>) -> Array<String>{

var newArray = inputArray

//do stuff with newArray

return newArray
}

-1

Essayer cette

var test = doArray([true,true,true])

test.count
func doArray(arr : [AnyObject]) -> [AnyObject] {

   var _arr = arr

return _arr
}

-1

Cela devrait le faire:
```
func myArrayFunc<T>(inputArray:Array<T>) -> Array<T> {

  var newArray = inputArray

  //do stuff with newArray

  return newArray
}
```
Vous déclarez le type générique Tqui est juste un espace réservé. Parce qu'il n'a pas d'exigences T peut être remplacé par n'importe quel type (lorsque la fonction est appelée). Si votre fonction peut être appelée comme ceci:
```
myArrayFunc([1, 2, 3])
```
ou ceci:
```
myArrayFunc(["a", "b", "c"])
```
La syntaxe préférée est généralement [T] plutôt que Array<T>cependant. (bien que les deux sont corrects)
```
func myArrayFunc<T>(inputArray: [T]) -> [T] {

  var newArray = inputArray

  //do stuff with newArray

  return newArray
}
```

Vous devez vous connecter pour publier un commentaire.