Verfügt PHP über integrierte Datenstrukturen?

Question

Ich schaue mir das an PHP-Handbuch, und ich sehe keinen Abschnitt über Datenstrukturen, die die meisten Sprachen haben, wie z. B. Listen und Mengen.Bin ich nur blind oder hat PHP so etwas nicht eingebaut?

Answer 1

Die einzige native Datenstruktur in PHP ist Array.Glücklicherweise sind Arrays recht flexibel und können auch als Hash-Tabellen verwendet werden.

http://www.php.net/array

Es gibt jedoch SPL, eine Art Klon von C++ STL.

http://www.php.net/manual/en/book.spl.php

Answer 2

PHP bietet Datenstrukturen über die Basiserweiterung der Standard PHP Library (SPL), die in PHP 5.0.0 standardmäßig verfügbar und kompiliert ist.

Die angebotenen Datenstrukturen sind mit PHP 5 >= 5.3.0 verfügbar und umfassen:

Doppelt verknüpfte Listen

Eine doppelt verknüpfte Liste (DLL) ist eine Liste von Knoten, die in beide Richtungen miteinander verknüpft sind.Die Operationen des Iterators, der Zugriff auf beide Enden, das Hinzufügen oder Entfernen von Knoten kosten O(1), wenn die zugrunde liegende Struktur eine DLL ist.Es bietet daher eine anständige Implementierung für Stacks und Warteschlangen.

• SplDoublyLinkedList-Klasse
  • SplStack-Klasse
  • SplQueue-Klasse

Haufenweise

Heaps sind baumartige Strukturen, die der Heap-Eigenschaft folgen:Jeder Knoten ist größer oder gleich seinen untergeordneten Knoten, wenn er mit der implementierten Vergleichsmethode verglichen wird, die global für den Heap ist.

• SplHeap-Klasse
  • SplMaxHeap-Klasse
  • SplMinHeap-Klasse
• SplPriorityQueue-Klasse

Arrays

Arrays sind Strukturen, die Daten kontinuierlich speichern und über Indizes zugänglich sind.Verwechseln Sie sie nicht mit PHP-Arrays:PHP-Arrays werden tatsächlich als geordnete Hashtabellen implementiert.

• SplFixedArray-Klasse

Karte

Eine Karte ist eine Datenstruktur, die Schlüssel-Wert-Paare enthält.PHP-Arrays können als Zuordnungen von Ganzzahlen/Strings zu Werten betrachtet werden.SPL bietet eine Zuordnung von Objekten zu Daten.Diese Karte kann auch als Objektsatz verwendet werden.

• SplObjectStorage-Klasse

Quelle: http://php.net/manual/en/spl.datastructures.php

Answer 3

Das assoziative Array kann für die meisten grundlegenden Datenstrukturen Hashtabelle, Warteschlange und Stapel verwendet werden.Aber wenn Sie so etwas wie einen Baum oder einen Haufen wollen, glaube ich nicht, dass sie standardmäßig existieren, aber ich bin sicher, dass es überall kostenlose Bibliotheken gibt.

Damit ein Array einen Stapel emulieren kann, verwenden Sie array_push() hinzufügen und array_pop() abheben

Damit ein Array eine Warteschlange emulieren kann, verwenden Sie array_push() in die Warteschlange stellen und array_shift() aus der Warteschlange nehmen

Ein assoziatives Array ist standardmäßig ein Hash.In PHP dürfen sie Zeichenfolgen als Indizes haben, sodass dies wie erwartet funktioniert:

$array['key'] = 'value';

Schließlich können Sie eine Art Binärbaum mit einem Array emulieren, was möglicherweise zu Platzverschwendung führt.Es ist nützlich, wenn Sie wissen, dass Sie einen kleinen Baum haben werden.Wenn Sie ein lineares Array verwenden, sagen Sie für jeden Index (i), dass Sie dessen linkes untergeordnetes Element auf den Index (2i+1) und sein rechtes untergeordnetes Element auf den Index (2i+2) setzen.

Alle diese Methoden werden ausführlich behandelt Dieser Artikel darüber, wie man JavaScript-Arrays dazu bringt, Datenstrukturen höherer Ebene zu emulieren.

Answer 4

Obwohl diese Frage 8 Jahre alt ist, poste ich eine Antwort, weil PHP 7 eine Erweiterung namens einführt ds Bereitstellung spezialisierter Datenstrukturen als Alternative zum Array.

Der ds,

• nutzt die Ds\ Namensraum.
• verfügt über 3 Schnittstellen, nämlichCollection, Sequence Und Hashable
• hat 8 Klassen, nämlich Vector, Deque,Queue, PriorityQueue, Map, Set, Stack, Und Pair

Weitere Informationen finden Sie unter Handbuch und auch Dieser Blogbeitrag hat einige tolle Informationen, einschließlich Benchmarks.

Answer 5

PHP verfügt über Arrays, die eigentlich assoziative Arrays sind und auch als Mengen verwendet werden können.Wie viele interpretierte Sprachen bietet PHP all dies unter einer Haube, anstatt verschiedene explizite Datentypen bereitzustellen.

Z.B.

$lst = array(1, 2, 3);
$hsh = array(1 => "This", 2 => "is a", 3 => "test");

/Bearbeiten:Werfen Sie auch einen Blick darauf im Handbuch.

Answer 6

PHPs Array dient gleichzeitig als Liste und Wörterbuch.

$myArray = array("Apples", "Oranges", "Pears");
$myScalar = $myArray[0] // == "Apples"

Oder um es als assoziatives Array zu verwenden:

$myArray = array("a"=>"Apples", "b"=>"Oranges", "c"=>"Pears");
$myScalar = $myArray["a"] // == "Apples"

Answer 7

Ich denke, Sie möchten vielleicht etwas konkreter werden. Wenn Sie von Datenstrukturen sprechen, gehen meine Gedanken in mehrere Richtungen ...

Arrays – Sie sind sicherlich gut dokumentiert und verfügbar in.(http://us.php.net/manual/en/book.array.php)

SQL-Daten – Hängt von der verwendeten Datenbank ab, die meisten sind jedoch verfügbar.(http://us.php.net/manual/en/book.mysql.php)

OOP – Abhängig von der Version können Objekte entworfen und implementiert werden.(http://us.php.net/manual/en/sprache.oop.php) Ich musste nach OOP suchen, um dies auf der PHP-Site zu finden.

Ich hoffe, das hilft, tut mir leid, wenn nicht.

Answer 8

Natürlich verfügt PHP über Datenstrukturen.Das Array in PHP ist unglaublich flexibel.Einige Beispiele:

$foo = array(
  'bar' => array(1,'two',3),
  'baz' => explode(" ", "Some nice words")
);

Dann steht Ihnen eine Fülle von Array-Funktionen zur Verfügung, um die Strukturen abzubilden, zu filtern, zu durchlaufen usw. oder umzuwandeln, umzudrehen, umzukehren usw.

Answer 9

Sie können jederzeit Ihre eigene erstellen, wenn Sie der Meinung sind, dass PHP keine bestimmte Art von Datenstruktur enthält.Hier ist zum Beispiel eine einfache Set-Datenstruktur, die durch ein Array unterstützt wird.

ArraySet: https://github.com/abelperez/collections/blob/master/ArraySet.php

class ArraySet
{
    /** Elements in this set */
    private $elements;

    /** the number of elements in this set */
    private $size = 0;

    /**
     * Constructs this set.
     */ 
    public function ArraySet() {
        $this->elements = array();
    }

    /**
     * Adds the specified element to this set if 
     * it is not already present.
     * 
     * @param any $element
     *
     * @returns true if the specified element was
     * added to this set.
     */
    public function add($element) {
        if (! in_array($element, $this->elements)) {
            $this->elements[] = $element;
            $this->size++;
            return true;
        }
        return false;
    }

    /**
     * Adds all of the elements in the specified 
     * collection to this set if they're not already present.
     * 
     * @param array $collection
     * 
     * @returns true if any of the elements in the
     * specified collection where added to this set. 
     */ 
    public function addAll($collection) {
        $changed = false;
        foreach ($collection as $element) {
            if ($this->add($element)) {
                $changed = true;
            }
        }
        return $changed;
    }

    /**
     * Removes all the elements from this set.
     */ 
    public function clear() {
        $this->elements = array();
        $this->size = 0;
    }

    /**
     * Checks if this set contains the specified element. 
     * 
     * @param any $element
     *
     * @returns true if this set contains the specified
     * element.
     */ 
    public function contains($element) {
        return in_array($element, $this->elements);
    }

    /**
     * Checks if this set contains all the specified 
     * element.
     * 
     * @param array $collection
     * 
     * @returns true if this set contains all the specified
     * element. 
     */ 
    public function containsAll($collection) {
        foreach ($collection as $element) {
            if (! in_array($element, $this->elements)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Checks if this set contains elements.
     * 
     * @returns true if this set contains no elements. 
     */ 
    public function isEmpty() {
        return count($this->elements) <= 0;
    }

    /**
     * Get's an iterator over the elements in this set.
     * 
     * @returns an iterator over the elements in this set.
     */ 
    public function iterator() {
        return new SimpleIterator($this->elements);
    }

    /**
     * Removes the specified element from this set.
     * 
     * @param any $element
     *
     * @returns true if the specified element is removed.
     */ 
    public function remove($element) {
        if (! in_array($element, $this->elements)) return false;

        foreach ($this->elements as $k => $v) {
            if ($element == $v) {
                unset($this->elements[$k]);
                $this->size--;
                return true;
            }
        }       
    }

    /**
     * Removes all the specified elements from this set.
     * 
     * @param array $collection
     *
     * @returns true if all the specified elemensts
     * are removed from this set. 
     */ 
    public function removeAll($collection) {
        $changed = false;
        foreach ($collection as $element) {
            if ($this->remove($element)) {
                $changed = true;
            } 
        }
        return $changed;
    }

    /**
     * Retains the elements in this set that are
     * in the specified collection.  If the specified
     * collection is also a set, this method effectively
     * modifies this set into the intersection of 
     * this set and the specified collection.
     * 
     * @param array $collection
     *
     * @returns true if this set changed as a result
     * of the specified collection.
     */ 
    public function retainAll($collection) {
        $changed = false;
        foreach ($this->elements as $k => $v) {
            if (! in_array($v, $collection)) {
                unset($this->elements[$k]);
                $this->size--;
                $changed = true;
            }
        }
        return $changed;
    }

    /**
     * Returns the number of elements in this set.
     * 
     * @returns the number of elements in this set.
     */ 
    public function size() {
        return $this->size; 
    }

    /**
     * Returns an array that contains all the 
     * elements in this set.
     * 
     * @returns an array that contains all the 
     * elements in this set.
     */ 
    public function toArray() {
        $elements = $this->elements;
        return $elements;   
    }
}

Answer 10

PHP kann auch eine haben Array von Arrays Dies wird als „mehrdimensionales Array“ oder „Matrix“ bezeichnet.Sie können zweidimensionale Arrays, dreidimensionale Arrays usw. haben.

Answer 11

Für den obligatorischen Bedarf an Datenstrukturen suchen Sie bitte nach SPL(PHP-Erweiterungen).Sie haben Datenstrukturen wie Heap, Linked-List usw.usw...

PHP verfügt nicht über die genauen Listen- und Einstellungsdatenstrukturen.Sie können jedoch durch Arrays (mit n Dimensionen) erreicht werden, die mehrere Daten in einem einzigen Cluster bereitstellen

$variable = array(
  'one' => array(1,'char',3),
  'two' => explode("single", "Multiple strings"),
  'three' => all(9,'nine',"nine")
);

Sie sind nicht genau wie eine Liste oder ein Set.Aber Array kann das ersetzen.Sie müssen also nicht nach anderen Datenstrukturen suchen.

Answer 12

Ja tut es.

<?php
$my_array = array("Bird","Cat","Cow");

list($a, $b, $c) = $my_array;
echo "I have several animals, a $a, a $b and a $c.";
?>

http://www.w3schools.com/php/func_array_list.asp

Answer 13

C-Sprachen ermöglichen das Erstellen einer Struktur und das anschließende Füllen dieser wie einen String-Puffer (Zeichen/Byte).Sobald der Puffer gefüllt ist, greift der Code über die Strukturelemente auf den Puffer zu.Es ist wirklich schön, strukturierte Dateien (Datenbank, Bilder usw.) auf diese Weise zu analysieren.Ich glaube nicht, dass man das mit PHP-Strukturen machen kann – oder irre ich mich (hoffentlich).

Ok – nun ja, PHP verfügt über Unpack und Pack – funktional gleich, aber nicht so elegant.