nette/component-model 3.1.0

component-model/bg/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Връща компонент. Опитът за извикване на недефиниран дъщерен компонент води до извикване на factory [createComponent($name |api:Nette\ComponentModel\Container::createComponent()]). Методът `createComponent($name)` извиква метода `createComponent<component name>` в текущия компонент и предава името на компонента като параметър. След това създаденият компонент се предава на текущия компонент като негов дъщерен компонент. Наричаме тези фабрики за компоненти, като те могат да бъдат реализирани в класове, наследени от `Container`.
 
 
-Итерация над подчинени компоненти .[#toc-iterating-over-children]
------------------------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Връща преките наследници като масив. Ключовете съдържат имената на тези компоненти. Забележка: във версия 3.0.x методът връщаше итератор вместо масив, като първият му параметър определяше дали да се итерира през компонентите в дълбочина, а вторият представляваше филтър на типа. Тези параметри са отпаднали.
 
-Методът [getComponents($deep = false, $type = null |api:Nette\ComponentModel\Container::getComponents()] ) се използва за итерация. Първият параметър определя дали компонентите да се итерират в дълбочина (или рекурсивно). Ако се използва `true`, се итерират не само всички негови дъщерни компоненти, но и всички деца на неговите дъщерни компоненти и т.н. Вторият параметър служи за допълнителен филтър по клас или интерфейс.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Връща цялата йерархия от компоненти, включително всички вложени дъщерни компоненти, като индексиран масив. Търсенето се извършва първо в дълбочина.
 
 
 Мониторинг на предците .[#toc-monitoring-of-ancestors]

component-model/cs/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Vrací komponentu. Při pokusu o získání nedefinovaného potomka je zavolána továrna `createComponent($name)`. Metoda `createComponent($name)` zavolá v aktuální komponentě metodu `createComponent<název komponenty>` a jako parametr jí předá název komponenty. Vytvořená komponenta je poté přidána do aktuální komponenty jako její potomek. Těmto metodám říkáme továrny na komponenty a mohou je implementovat potomci třídy `Container`.
 
 
-Iterování nad potomky
----------------------
+getComponents(): array .[method]
+--------------------------------
+Vrací přímé potomky jako pole. Klíče obsahují názvy těchto komponent. Poznámka: ve verzi 3.0.x metoda namísto pole vracela iterátor a její první parametr určoval, zda se mají komponenty procházet do hloubky, a druhý představoval typový filtr. Tyto parametry jsou deprecated.
 
-K iterování slouží metoda [getComponents($deep = false, $type = null)|api:Nette\ComponentModel\Container::getComponents()]. První parametr určuje, zda se mají komponenty procházet do hloubky (neboli rekurzivně). S hodnotou `true` tedy nejen projde všechny komponenty, jichž je rodičem, ale také potomky svých potomků atd. Druhý parametr slouží jako volitelný filtr podle tříd nebo rozhraní.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Získá celou hierarchii komponent včetně všech vnořených podřízených komponent jako indexované pole. Prohledávání jde nejprve do hloubky.
 
 
 Monitorování předků

component-model/de/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Gibt eine Komponente zurück. Der Versuch, ein undefiniertes Kind aufzurufen, führt zum Aufruf der Fabrik [createComponent($name) |api:Nette\ComponentModel\Container::createComponent()]. Die Methode `createComponent($name)` ruft die Methode `createComponent<component name>` in der aktuellen Komponente auf und übergibt den Namen der Komponente als Parameter. Die erstellte Komponente wird dann an die aktuelle Komponente als ihr Kind übergeben. Wir nennen diese Komponentenfabriken, sie können in von `Container` geerbten Klassen implementiert werden.
 
 
-Iteration über Kinder .[#toc-iterating-over-children]
------------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Gibt direkte Nachkommen als Array zurück. Die Schlüssel enthalten die Namen dieser Komponenten. Hinweis: In Version 3.0.x gab die Methode einen Iterator statt eines Arrays zurück. Der erste Parameter gab an, ob durch die Komponenten in der Tiefe iteriert werden sollte, und der zweite Parameter stellte einen Typfilter dar. Diese Parameter sind veraltet.
 
-Die Methode [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] wird zur Iteration verwendet. Der erste Parameter gibt an, ob die Komponenten in der Tiefe (oder rekursiv) durchlaufen werden sollen. Bei `true` werden nicht nur alle untergeordneten Komponenten durchlaufen, sondern auch alle untergeordneten Komponenten der untergeordneten Komponenten, usw. Der zweite Parameter dient als optionaler Filter nach Klasse oder Schnittstelle.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Gibt die gesamte Hierarchie der Komponenten, einschließlich aller verschachtelten untergeordneten Komponenten, als indiziertes Array zurück. Die Suche geht zunächst in die Tiefe.
 
 
 Überwachung der Vorfahren .[#toc-monitoring-of-ancestors]

component-model/el/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Επιστρέφει ένα συστατικό. Η απόπειρα κλήσης απροσδιόριστου παιδιού προκαλεί κλήση του εργοστασίου [createComponent($name) |api:Nette\ComponentModel\Container::createComponent()]. Η μέθοδος `createComponent($name)` καλεί τη μέθοδο `createComponent<component name>` στο τρέχον συστατικό και περνά το όνομα του συστατικού ως παράμετρο. Το συστατικό που δημιουργήθηκε περνάει στη συνέχεια στο τρέχον συστατικό ως παιδί του. Ονομάζουμε αυτά τα εργοστάσια συστατικών, μπορούν να υλοποιηθούν σε κλάσεις που κληρονομούνται από το `Container`.
 
 
-Επανάληψη σε παιδιά .[#toc-iterating-over-children]
----------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Επιστρέφει τους άμεσους απογόνους ως πίνακα. Τα κλειδιά περιέχουν τα ονόματα αυτών των στοιχείων. Σημείωση: στην έκδοση 3.0.x, η μέθοδος επέστρεφε έναν επαναλήπτη αντί για έναν πίνακα, και η πρώτη παράμετρος όριζε αν θα επαναλαμβάνονταν τα συστατικά σε βάθος και η δεύτερη αντιπροσώπευε ένα φίλτρο τύπου. Αυτές οι παράμετροι έχουν καταργηθεί.
 
-Η μέθοδος [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] χρησιμοποιείται για την επανάληψη. Η πρώτη παράμετρος καθορίζει αν θα διατρέξει τα συστατικά σε βάθος (ή αναδρομικά). Με την `true`, δεν επαναλαμβάνει μόνο όλα τα παιδιά της, αλλά και όλα τα παιδιά των παιδιών της, κ.λπ. Η δεύτερη παράμετρος εξυπηρετεί ως προαιρετικό φίλτρο ανά κλάση ή διεπαφή.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Επιστρέφει ολόκληρη την ιεραρχία των στοιχείων, συμπεριλαμβανομένων όλων των φωλιασμένων θυγατρικών στοιχείων ως πίνακα με ευρετήριο. Η αναζήτηση γίνεται πρώτα σε βάθος.
 
 
 Παρακολούθηση των προγόνων .[#toc-monitoring-of-ancestors]

component-model/en/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Returns a component. Attempt to call undefined child causes invoking of factory [createComponent($name)|api:Nette\ComponentModel\Container::createComponent()]. Method `createComponent($name)` invokes method `createComponent<component name>` in current component and it passes name of the component as a parameter. Created component is then passed to current component as its child. We call theese component factories, they can be implemented in classes inherited from `Container`.
 
 
-Iterating over Children
------------------------
+getComponents(): array .[method]
+--------------------------------
+Returns direct descendants as an array. The keys contain the names of these components. Note: in version 3.0.x, the method returned an iterator instead of an array, and its first parameter specified whether to iterate through the components in depth, and the second represented a type filter. These parameters are deprecated.
 
-The [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] method is used for iteration. The first parameter specifies whether to traverse the components in depth (or recursively). With `true`, it not only iterates all its children, but also all children of its children, etc. Second parameter serves as an optional filter by class or interface.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Returns the entire hierarchy of components, including all nested child components as indexed array. The search goes in depth first.
 
 
 Monitoring of Ancestors

component-model/es/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Devuelve un componente. El intento de llamar a un hijo no definido provoca la invocación de la fábrica [createComponent($nombre) |api:Nette\ComponentModel\Container::createComponent()]. El método `createComponent($name)` invoca el método `createComponent<component name>` en el componente actual y pasa el nombre del componente como parámetro. El componente creado se pasa al componente actual como hijo. Llamamos a estas fábricas de componentes, pueden ser implementadas en clases heredadas de `Container`.
 
 
-Iterando sobre hijos .[#toc-iterating-over-children]
-----------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Devuelve los descendientes directos como una matriz. Las claves contienen los nombres de estos componentes. Nota: en la versión 3.0.x, el método devolvía un iterador en lugar de un array, y su primer parámetro especificaba si iterar a través de los componentes en profundidad, y el segundo representaba un filtro de tipo. Estos parámetros están obsoletos.
 
-El método [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] se utiliza para la iteración. El primer parámetro especifica si se recorren los componentes en profundidad (o recursivamente). Con `true`, no sólo itera todos sus hijos, sino también todos los hijos de sus hijos, etc. El segundo parámetro sirve como filtro opcional por clase o interfaz.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Devuelve toda la jerarquía de componentes, incluidos todos los componentes hijos anidados como matriz indexada. La búsqueda va primero en profundidad.
 
 
 Supervisión de antepasados .[#toc-monitoring-of-ancestors]

component-model/fr/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Renvoie un composant. La tentative d'appeler un enfant non défini entraîne l'invocation de la fabrique [createComponent($name) |api:Nette\ComponentModel\Container::createComponent()]. La méthode `createComponent($name)` invoque la méthode `createComponent<component name>` dans le composant courant et passe le nom du composant comme paramètre. Le composant créé est ensuite transmis au composant courant en tant que son enfant. Nous appelons ces usines de composants, elles peuvent être implémentées dans des classes héritées de `Container`.
 
 
-Itération sur les enfants .[#toc-iterating-over-children]
----------------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Renvoie les descendants directs sous la forme d'un tableau. Les clés contiennent les noms de ces composants. Note : dans la version 3.0.x, la méthode renvoyait un itérateur au lieu d'un tableau, et son premier paramètre spécifiait s'il fallait itérer à travers les composants en profondeur, et le second représentait un filtre de type. Ces paramètres sont obsolètes.
 
-La méthode [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] est utilisée pour l'itération. Le premier paramètre indique s'il faut parcourir les composants en profondeur (ou de manière récursive). Avec `true`, l'itération porte non seulement sur tous ses enfants, mais aussi sur tous les enfants de ses enfants, etc. Le deuxième paramètre sert de filtre optionnel par classe ou interface.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Renvoie toute la hiérarchie des composants, y compris tous les composants enfants imbriqués, sous la forme d'un tableau indexé. La recherche se fait d'abord en profondeur.
 
 
 Surveillance des ancêtres .[#toc-monitoring-of-ancestors]

component-model/hu/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Visszaad egy komponenst. A nem definiált gyermek hívásának kísérlete a factory [createComponent($name) |api:Nette\ComponentModel\Container::createComponent()] meghívását okozza. A `createComponent($name)` metódus meghívja a metódust `createComponent<component name>` az aktuális komponensben, és paraméterként átadja a komponens nevét. A létrehozott komponens ezután átadásra kerül az aktuális komponensnek, mint annak gyermeke. Ezeket a komponens gyáraknak nevezzük, a `Container`-tól örökölt osztályokban implementálhatók.
 
 
-Iterálás a gyermekeken .[#toc-iterating-over-children]
-------------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Közvetlen leszármazottakat ad vissza tömbként. A kulcsok ezen komponensek nevét tartalmazzák. Megjegyzés: a 3.0.x verzióban a módszer tömb helyett egy iterátort adott vissza, és az első paramétere megadta, hogy a komponenseket mélységben iterálja-e, a második pedig egy típusszűrőt jelentett. Ezek a paraméterek elavultak.
 
-Az iterációhoz a [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] metódust használjuk. Az első paraméter megadja, hogy a komponensek mélységben (vagy rekurzívan) legyenek-e végigjárva. A `true` esetén nem csak az összes gyermekét iterálja, hanem a gyermekeinek összes gyermekét is, stb. A második paraméter kiszolgál, mint opcionális szűrő osztály vagy interfész szerint.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Visszaadja a komponensek teljes hierarchiáját, beleértve az összes beágyazott gyermekkomponenst indexelt tömbként. A keresés először a mélységben történik.
 
 
 Az ősök figyelése .[#toc-monitoring-of-ancestors]

component-model/it/@home.texy

@@ -30,18 +30,14 @@ getComponent(string $name): ?Component .[method]
 Restituisce un componente. Il tentativo di chiamare un figlio non definito causa l'invocazione del factory [createComponent($nome) |api:Nette\ComponentModel\Container::createComponent()]. Il metodo `createComponent($name)` invoca il metodo `createComponent<component name>` nel componente corrente e passa il nome del componente come parametro. Il componente creato viene quindi passato al componente corrente come suo figlio. Questi factory di componenti possono essere implementati in classi ereditate da `Container`.
 
 
-Iterazione sui figli .[#toc-iterating-over-children]
-----------------------------------------------------
+getComponents(): array .[method]
+--------------------------------
+Restituisce i discendenti diretti come array. Le chiavi contengono i nomi dei componenti. Nota: nella versione 3.0.x, il metodo restituiva un iteratore invece di un array e il primo parametro specificava se iterare i componenti in profondità e il secondo rappresentava un filtro di tipo. Questi parametri sono deprecati.
 
-Il metodo [getComponents($deep = false, $type = null) |api:Nette\ComponentModel\Container::getComponents()] è usato per l'iterazione. Il primo parametro specifica se si deve attraversare i componenti in profondità (o in modo ricorsivo). Con `true`, non solo vengono iterati tutti i suoi figli, ma anche tutti i figli dei suoi figli, ecc. Il secondo parametro serve come filtro opzionale per classe o interfaccia.
 
-```php
-foreach ($form->getComponents(true, Nette\Forms\IControl::class) as $control) {
-	if (!$control->getRules()->validate()) {
-		// ...
-	}
-}
-```
+getComponentTree(): array .[method]{data-version:3.1.0}
+-------------------------------------------------------
+Restituisce l'intera gerarchia di componenti, compresi tutti i componenti figli annidati, come array indicizzato. La ricerca va prima in profondità.
 
 
 Monitoraggio degli antenati .[#toc-monitoring-of-ancestors]

component-model/meta.json

@@ -1,5 +1,5 @@
 {
-	"version": "4.0",
+	"version": "3.x",
 	"repo": "nette/component-model",
 	"composer": "nette/component-model"
 }