strip_tags - ¿PHP tiene estructuras de datos incorporadas?

strip_tags wordpress

Question

Estoy mirando el Manual de PHP , y no estoy viendo una sección sobre estructuras de datos que tienen la mayoría de los idiomas, como listas y conjuntos. ¿Estoy solo ciego o PHP no tiene algo como esto integrado?

Answer 1

Aunque esta pregunta tiene 8 años, estoy publicando una respuesta porque PHP 7 presenta una extensión llamada ds proporciona estructuras de datos especializadas como alternativa a la matriz.

El ds ,

• usa el espacio de nombres Ds/
• tiene 3 interfaces a saber, Collection , Sequence y Hashable
• tiene 8 clases, a saber, Vector , Deque , Queue , PriorityQueue , Map , Set , Stack y Pair

Para obtener más información, consulte el Manual y también esta publicación de blog contiene información excelente, incluidos los puntos de referencia.

Answer 2

Creo que quizás quieras ser un poco más específico, cuando dices estructuras de datos mi mente va en algunas direcciones ...

Arrays: están bien documentados y están disponibles en. ( http://us.php.net/manual/en/book.array.php )

Datos SQL: Depende de la base de datos que esté utilizando, pero la mayoría están disponibles. ( http://us.php.net/manual/en/book.mysql.php )

OOP: según la versión, los objetos se pueden diseñar e implementar. ( http://us.php.net/manual/en/language.oop.php ) Tuve que buscar OOP para encontrar esto en el sitio php.

Espero que ayude, lo siento si no lo hace.

Answer 3

El array de PHP funciona como una lista y un diccionario.

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

O para usarlo como una matriz asociativa:

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

Answer 4

La única estructura de datos nativa en PHP es array. Afortunadamente, las matrices son bastante flexibles y también se pueden usar como tablas hash.

http://www.php.net/array

Sin embargo, hay SPL que es una especie de clon de C ++ STL.

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

Answer 5

La matriz asociativa se puede usar para la mayoría de las estructuras de datos básicas hashtable, queue, stack. Pero si quieres algo así como un árbol o un montón, no creo que existan por defecto, pero estoy seguro de que hay bibliotecas gratuitas en cualquier lugar.

Para hacer que una matriz emule una pila, utiliza array_push() para agregar y array_pop() para despegar

Para hacer que una matriz emule una cola, utiliza array_push() para array_shift() y array_shift() para dequeue

Una matriz asociativa es un hash por defecto. En PHP se les permite tener cadenas como índices para que esto funcione como se esperaba:

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

Finalmente, puedes emular un árbol binario con una matriz con el potencial de tener un espacio desperdiciado. Es útil si sabes que vas a tener un árbol pequeño. Usando una matriz lineal, dices para cualquier índice (i) que colocas al hijo izquierdo en el índice (2i + 1) y el hijo derecho en el índice (2i + 2).

Todos estos métodos están cubiertos muy bien en este artículo sobre cómo hacer que las matrices de JavaScript emulen estructuras de datos de nivel superior.

Answer 6

Los lenguajes C permitirán crear una estructura y luego llenarla como un búfer de cadena (char / byte). Una vez que se llena, el código accede al buffer a través de los miembros de la estructura. Es realmente agradable analizar archivos estructurados (bases de datos, imágenes, etc.) de esa manera. No creo que puedas hacer eso con estructuras de PHP, o estoy (con suerte) equivocado.

Ok, bueno, PHP tiene desempaquetar y empacar, funcionalmente igual, pero no tan elegante.

Answer 7

PHP ofrece estructuras de datos a través de la extensión básica Biblioteca PHP Estándar (SPL), que está disponible y compilada de manera predeterminada en PHP 5.0.0.

Las estructuras de datos ofrecidas están disponibles con PHP 5> = 5.3.0, e incluye:

Listas doblemente enlazadas

Una Lista doblemente enlazada (DLL) es una lista de nodos vinculados en ambas direcciones entre sí. Las operaciones del iterador, el acceso a ambos extremos, la adición o eliminación de nodos tienen un costo de O (1) cuando la estructura subyacente es una DLL. Por lo tanto, proporciona una implementación decente para stacks y colas.

• Clase SplDoublyLinkedList
  • Clase SplStack
  • Clase SplQueue

Muchísimo

Los montículos son estructuras en forma de árbol que siguen la propiedad del montón: cada nodo es mayor o igual que sus hijos, cuando se compara con el método de comparación implementado que es global para el montón.

• Clase SplHeap
  • Clase SplMaxHeap
  • Clase SplMinHeap
• Clase SplPriorityQueue

Arrays

Las matrices son estructuras que almacenan los datos de forma continua, accesible a través de índices. No los confunda con matrices PHP: las matrices PHP se implementan de hecho como hashtables ordenadas.

• Clase SplFixedArray

Mapa

Un mapa es una estructura de datos que contiene pares clave-valor. Los arrays de PHP se pueden ver como mapas de enteros / cadenas a valores. SPL proporciona un mapa de objetos a datos. Este mapa también se puede usar como un conjunto de objetos.

• Clase SplObjectStorage

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

Answer 8

PHP también puede tener una matriz de matrices que se llama una "matriz multidimensional" o "matriz". Puede tener matrices bidimensionales, matrices tridimensionales, etc.

Answer 9

PHP tiene matrices que en realidad son matrices asociativas y también se pueden usar como conjuntos. Al igual que muchos lenguajes interpretados, PHP ofrece todo esto bajo un mismo objetivo en lugar de proporcionar diferentes tipos de datos explícitos.

P.ej

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

/ Editar: También, eche un vistazo en el manual .

Answer 10

Para la necesidad Obligatoria de estructuras de datos, busque el SPL (Extensiones de PHP). Están teniendo estructuras de datos como heap, linked-list, .. etc ...

PHP no tiene la lista y establece las estructuras de datos exactamente. pero pueden lograrse mediante una matriz (con n dimensiones), que proporcionan múltiples datos con un solo clúster

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

No son exactamente como lista o conjunto. Pero array puede reemplazar eso. Entonces no hay necesidad de buscar otras estructuras de datos.

Answer 11

Por supuesto, PHP tiene estructuras de datos. La matriz en php es increíblemente flexible. Algunos ejemplos:

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

Luego tiene una plétora absoluta de funciones de matriz disponibles para asignar / filtrar / caminar / etc. las estructuras, o convertir, voltear, invertir, etc.

Answer 12

Sí lo hace.

<?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

Siempre puede crear uno propio si no cree que PHP incluye un tipo específico de estructura de datos. Por ejemplo, aquí hay una estructura de datos de conjunto simple respaldada por una matriz.

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;   
    }
}