Jak stworzyć pustą tablicę w Swift?

Jestem naprawdę zdezorientowany sposobem, w jaki tworzymy tablicę w Swift. Czy możesz mi powiedzieć, na ile sposobów można utworzyć pustą tablicę z pewnymi szczegółami?

Proszę bardzo:

var yourArray = [String]()

Powyższe działa również dla innych typów, a nie tylko dla ciągów. To tylko przykład.

Dodawanie do niego wartości

Zakładam, że w końcu będziesz chciał dodać do tego wartość!

yourArray.append("String Value")

Lub

let someString = "You can also pass a string variable, like this!"
yourArray.append(someString)

Dodaj przez wstawienie

Gdy masz już kilka wartości, możesz wstawić nowe wartości zamiast dołączać. Na przykład, jeśli chcesz wstawić nowe obiekty na początku tablicy (zamiast dołączać je na końcu):

yourArray.insert("Hey, I'm first!", atIndex: 0)

Lub możesz użyć zmiennych, aby uczynić wkładkę bardziej elastyczną:

let lineCutter = "I'm going to be first soon."
let positionToInsertAt = 0
yourArray.insert(lineCutter, atIndex: positionToInsertAt)

W końcu możesz chcieć usunąć niektóre rzeczy

var yourOtherArray = ["MonkeysRule", "RemoveMe", "SwiftRules"]
yourOtherArray.remove(at: 1)

Powyższe działa świetnie, gdy wiesz, gdzie w tablicy znajduje się wartość (to znaczy, gdy znasz wartość jej indeksu). Ponieważ wartości indeksu zaczynają się od 0, drugi wpis będzie miał indeks 1.

Usuwanie wartości bez znajomości indeksu

A co jeśli tego nie zrobisz? Co się stanie, jeśli twoja tablicaOtherArray ma setki wartości i wiesz tylko, że chcesz usunąć tę równą „RemoveMe”?

if let indexValue = yourOtherArray.index(of: "RemoveMe") {
    yourOtherArray.remove(at: indexValue)
}

To powinno zacząć!

var myArr1 = [AnyObject]()

może przechowywać dowolny przedmiot

var myArr2 = [String]()

może przechowywać tylko ciąg

Możesz użyć

var firstNames: [String] = []

Szybki 3

Istnieją trzy (3) sposoby tworzenia pustej tablicy w języku Swift, przy czym metoda skrócona jest zawsze preferowana.

Metoda 1: skrócona składnia

var arr = [Int]()

Metoda 2: inicjator tablicy

var arr = Array<Int>()

Metoda 3: Tablica z literałem tablicowym

var arr:[Int] = []

Metoda 4: Kredyt trafia do @BallpointBen

var arr:Array<Int> = []

Istnieją 2 główne sposoby szybkiego tworzenia / inicjowania tablicy.

var myArray = [Double]()

Stworzyłoby to tablicę Doubles.

var myDoubles = [Double](count: 5, repeatedValue: 2.0)

Stworzyłoby to tablicę 5 podwójnych, wszystkie zainicjowane wartością 2,0.

Jeśli chcesz zadeklarować pustą tablicę typu string, możesz to zrobić na 5 różnych sposobów: -

var myArray: Array<String> = Array()
var myArray = [String]()
var myArray: [String] = []
var myArray = Array<String>()
var myArray:Array<String> = []

Tablica dowolnego typu: -

    var myArray: Array<AnyObject> = Array()
    var myArray = [AnyObject]()
    var myArray: [AnyObject] = []
    var myArray = Array<AnyObject>()
    var myArray:Array<AnyObject> = []

Tablica typu Integer: -

    var myArray: Array<Int> = Array()
    var myArray = [Int]()
    var myArray: [Int] = []
    var myArray = Array<Int>()
    var myArray:Array<Int> = []

Oto kilka typowych zadań w Swift 4, których możesz używać jako odniesienia, dopóki nie przyzwyczaisz się do rzeczy.

    let emptyArray = [String]()
    let emptyDouble: [Double] = []

    let preLoadArray = Array(repeating: 0, count: 10) // initializes array with 10 default values of the number 0

    let arrayMix = [1, "two", 3] as [Any]
    var arrayNum = [1, 2, 3]
    var array = ["1", "two", "3"]
    array[1] = "2"
    array.append("4")
    array += ["5", "6"]
    array.insert("0", at: 0)
    array[0] = "Zero"
    array.insert(contentsOf: ["-3", "-2", "-1"], at: 0)
    array.remove(at: 0)
    array.removeLast()
    array = ["Replaces all indexes with this"]
    array.removeAll()

    for item in arrayMix {
        print(item)
    }

    for (index, element) in array.enumerated() {
        print(index)
        print(element)
    }

    for (index, _) in arrayNum.enumerated().reversed() {
        arrayNum.remove(at: index)
    }

    let words = "these words will be objects in an array".components(separatedBy: " ")
    print(words[1])

    var names = ["Jemima", "Peter", "David", "Kelly", "Isabella", "Adam"]
    names.sort() // sorts names in alphabetical order

    let nums = [1, 1234, 12, 123, 0, 999]
    print(nums.sorted()) // sorts numbers from lowest to highest

Tablica w swift jest zapisywana jako ** Array <Element> **, gdzie Element jest typem wartości, które tablica może przechowywać.

Tablicę można zainicjować jako:

let emptyArray = [String]()

Pokazuje, że jest to tablica typu string

Typ zmiennej emptyArray jest wywnioskowany jako [String] z typu inicjatora.

Do tworzenia tablicy typu string z elementami

var groceryList: [String] = ["Eggs", "Milk"]

Lista spożywcza została zainicjowana dwoma elementami

Zmienna groceryList jest zadeklarowana jako „tablica wartości ciągów” zapisywana jako [String]. Ta konkretna tablica ma określony typ wartości String, dozwolone jest przechowywanie tylko wartości String.

Istnieją różne właściwości tablicy, takie jak:

- Aby sprawdzić, czy tablica zawiera elementy (jeśli tablica jest pusta, czy nie)

Właściwość isEmpty (Boolean) do sprawdzania, czy właściwość count jest równa 0:

if groceryList.isEmpty {
    print("The groceryList list is empty.")
} else {
    print("The groceryList is not empty.")
}

- Dołączanie (dodawanie) elementów w tablicy

Możesz dodać nowy element na końcu tablicy, wywołując metodę append (_ :) tablicy:

groceryList.append("Flour")

Lista zakupów zawiera teraz 3 elementy.

Alternatywnie, dołącz tablicę jednego lub więcej zgodnych elementów za pomocą operatora przypisania dodawania (+ =):

groceryList += ["Baking Powder"]

Lista zakupów zawiera teraz 4 elementy

groceryList += ["Chocolate Spread", "Cheese", "Peanut Butter"]

Lista zakupów zawiera teraz 7 pozycji

Zgodnie ze Swift 5

    // An array of 'Int' elements
    let oddNumbers = [1, 3, 5, 7, 9, 11, 13, 15]

    // An array of 'String' elements
    let streets = ["Albemarle", "Brandywine", "Chesapeake"]

    // Shortened forms are preferred
    var emptyDoubles: [Double] = []

    // The full type name is also allowed
    var emptyFloats: Array<Float> = Array()

możesz usunąć zawartość tablicy, przekazując jej indeks lub możesz usunąć wszystko

    var array = [String]()
    print(array)
    array.append("MY NAME")
    print(array)
    array.removeFirst()
    print(array)
    array.append("MY NAME")
    array.removeLast()
    array.append("MY NAME1")
    array.append("MY NAME2")
    print(array)
    array.removeAll()
    print(array)

Szybki 5

// Create an empty array
var emptyArray = [String]()

// Add values to array by appending (Adds values as the last element)
emptyArray.append("Apple")
emptyArray.append("Oppo")

// Add values to array by inserting (Adds to a specified position of the list)
emptyArray.insert("Samsung", at: 0)

// Remove elements from an array by index number
emptyArray.remove(at: 2)

// Remove elements by specifying the element
if let removeElement = emptyArray.firstIndex(of: "Samsung") {
    emptyArray.remove(at: removeElement)
}

Podano podobną odpowiedź, ale to nie działa w przypadku najnowszej wersji Swift (Swift 5), więc oto zaktualizowana odpowiedź. Mam nadzieję, że to pomoże! :)

Inicjowanie tablicy z predefiniowaną liczbą:

Array(repeating: 0, count: 10)

Często używam tego do mapowania instrukcji, w których potrzebuję określonej liczby pozorowanych obiektów. Na przykład,

let myObjects: [MyObject] = Array(repeating: 0, count: 10).map { _ in return MyObject() }

Zgodny z: Xcode 6.0.1+

Możesz utworzyć pustą tablicę, określając typ elementu tablicy w deklaracji.

Na przykład:

// Shortened forms are preferred
var emptyDoubles: [Double] = []

// The full type name is also allowed
var emptyFloats: Array<Float> = Array()

Przykład ze strony programisty Apple (tablica):

Mam nadzieję, że pomoże to każdemu, kto natknie się na tę stronę.