Élément de la liste des valeurs 1s. Structure de collecte universelle

Syntaxe complète(Cliquez pour agrandir)

Liste de valeurs

La description:

Une liste de valeurs est un objet non stocké dans la base de données qui permet de construire des ensembles dynamiques de valeurs pour résoudre des problèmes d'interface et les manipuler (ajouter, modifier, supprimer des éléments, trier). Il peut être rempli avec des valeurs de tout type, c'est-à-dire dans une liste, les types de valeurs stockées peuvent être différents. Un exemple d'utilisation de cet objet consiste à organiser la sélection d'un document spécifique dans une liste de documents possibles générée par un algorithme complexe.

Eléments de collecte : ItemListValues

Il est possible de parcourir la collection d'un objet en utilisant l'opérateur Pour chaque ... A partir de ... Cycle. Le parcours sélectionne les éléments de la collection.

Il est possible d'accéder à un élément d'une collection à l'aide de l'opérateur [...]. L'index de l'élément est passé en argument ( numérotation à partir de 0).

Propriétés:

Méthodes :

Constructeurs :

De quoi parle l'article

Cet article continue la série d'articles "Premiers pas de développement sur 1C". Il traite des principes de travail avec des collections génériques. Après avoir lu l'article, vous saurez :

• Que sont les collections génériques, quand et dans quels cas les utiliser ?
• Quel est le point commun entre toutes les collections universelles ? Quelles techniques peuvent être utilisées pour travailler avec chacun d'eux?
• Qu'est-ce qu'un tableau, comment et quand l'utiliser ? Quelles méthodes a-t-il ?
• Pourquoi utiliser une structure ? Quelle est la différence avec un tableau ?
• Quand utiliser une liste de valeurs ? Comment l'afficher sur le formulaire ?
• Conformité - qu'est-ce que c'est et quand l'utiliser ? Quels sont les avantages en termes de structure ?
• A quoi sert un tableau de valeurs ? Comment décrire sa structure ? Comment ajouter/supprimer des lignes ? Comment l'amener au formulaire?
• Arbre de valeur - à quoi sert-il ? Comment remplir et afficher sur le formulaire ? Comment travailler avec lui ?

Applicabilité

L'article traite de la plateforme 1C:Enterprise 8.3 de l'édition actuelle.

Comment travailler avec des collections universelles en 1C

Une collection de valeurs est une sorte de conteneur qui peut généralement contenir n'importe quel nombre d'éléments. Dans le même temps, il n'y a souvent pas de restrictions strictes sur le type de données.

Vous pouvez ajouter des valeurs à une collection générique. Toutes les valeurs de la collection peuvent être parcourues. Ces collections sont principalement utilisées pour certains types de traitement dans les algorithmes. Ceux. ce sont des structures dynamiques qui existent pendant la durée de l'algorithme.

Il est important de comprendre que les collections ne sont pas stockées dans la base de données (nous ne parlons pas du type de données Value Store, qui peut stocker presque tous les types de données).

Exister différentes sortes collections génériques : Array, Structure, Mapping, Fixed Array, Value Table, partie tabulaire etc. Mais toutes les collections ont un comportement similaire.

Une collection peut être créée à la suite d'une fonction (la fonction renvoie une collection générique en tant que valeur).

Disponible nouvelle collection manuellement en appelant le constructeur et en créant une instance de la classe.

Par exemple: NotreTableau = Nouveau Tableau ;

Les constructeurs de nombreuses collections génériques sont paramétrés.

Ainsi, dans le constructeur de vous pouvez spécifier le nombre d'éléments dans les dimensions correspondantes. Ceux. vous pouvez immédiatement déclarer multidimensionnel .

La description correspondante du constructeur se trouve dans l'assistant de syntaxe.

Ainsi, à l'aide des paramètres du constructeur, vous pouvez immédiatement définir le comportement souhaité de cet objet.

Mais les paramètres sont facultatifs, le développeur ne peut pas les définir et définir plus avant le comportement du Array comme il l'entend.

Presque toutes les collections génériques peuvent être créées à l'aide d'un constructeur (à l'exception des tableparts, qui agissent comme des objets de configuration).

Pour les collections génériques, il existe concepts généraux comme l'index et le numéro. Chaque élément de la collection a un index. L'indice commence à zéro.

Pour accéder à un élément Notretableau, vous pouvez utiliser l'accès à l'index, pour cela l'index est indiqué entre crochets.

Par exemple, Notretableau. Notez que dans ce cas, le système renvoie l'élément du tableau à l'index 3, et dans l'ordre, il s'agit du quatrième élément du tableau.

Pour certaines collections, il existe également le concept de numéro de ligne. Le numéro de ligne commence par un. Par exemple, pour une section tabulaire, il existe une propriété telle qu'un numéro de ligne. Il est important de garder à l'esprit que si nous connaissons le numéro de ligne et que nous voulons y accéder par index, la valeur un de moins que le numéro de ligne doit être utilisée comme index.

La notion de numéro de ligne n'existe pas pour toutes les collections, mais principalement pour celles qui peuvent être affichées dans l'interface utilisateur.

Pour toutes les collections, le parcours des éléments de la collection est utilisé. Le contournement est possible de deux manières : cycle pour et cycle Pour chaque.

Pour la plupart des collections génériques, les méthodes suivantes s'appliquent : Count, Index, Add, Insert, Delete et Find.

Count est une fonction qui renvoie le nombre d'éléments d'une collection. Il peut être utilisé avant la boucle Pour, comme le montre la figure.

La méthode Index n'existe pas pour toutes les collections, mais uniquement pour celles dont les éléments peuvent être référencés. Un exemple est Tableau des valeurs.

Tableau des valeurs est une collection spécifique de chaînes, les chaînes peuvent contenir différentes colonnes avec différents types valeurs.

Chaque ligne est une entité indépendante. Vous pouvez obtenir un lien vers celui-ci, via cette ligne, vous pouvez accéder aux valeurs des colonnes de cette ligne.

La méthode Index vous permet de déterminer quel index correspond à une ligne donnée (c'est-à-dire la position actuelle de la ligne dans la table). Les valeurs d'index commencent à zéro.

Des méthodes pour ajouter de nouvelles valeurs à cette collection existent dans presque toutes les collections génériques. La figure montre comment remplir un tableau avec des valeurs de 0 à 10 de deux manières.

Pour ajouter un élément à un Array, on peut utiliser la méthode Ajouter, indiquez la valeur ajoutée entre parenthèses. Dans ce cas, la valeur sera ajoutée à la fin de la liste, c'est-à-dire Le tableau augmentera constamment en raison de la dernière position.

Une autre méthode qui permet d'ajouter des valeurs à une collection est la méthode Insérer. Elle diffère de la méthode Ajouter afin que vous puissiez spécifier où insérer l'élément ajouté.

Syntaxe: Insérer (,)

Le premier paramètre spécifie l'index dans lequel la nouvelle valeur sera insérée. Ceux. nous pouvons, par exemple, spécifier que chaque valeur doit être insérée au début de la liste (la deuxième manière dans la figure ci-dessus).

La méthode est utilisée pour supprimer des éléments d'une collection. Effacer. Dans la méthode Delete, il est indiqué par index quel élément nous allons supprimer.

Syntaxe: Effacer()
Exemple d'utilisation : OurArray.Delete(5);

Il convient de noter que pour les collections où les chaînes représentent une entité indépendante (par exemple, pour ValeursTable), nous pouvons également utiliser la méthode get index pour supprimer la ligne donnée ultérieurement.

Presque toutes les collections ont une méthode pour trouver une valeur - Trouver. La méthode reçoit la valeur que nous voulons trouver. Dans certaines collections, vous pouvez mettre des restrictions.

Par exemple, dans Tableau des valeurs vous pouvez spécifier ces lignes, ces colonnes dans lesquelles vous souhaitez rechercher.

Si la valeur est trouvée, cette méthode renvoie l'index ou une chaîne spécifique. Si aucune valeur n'est trouvée, une valeur de type est renvoyée. Indéfini. Lorsqu'il est appliqué à un tableau, renvoie Indice, ou la valeur Indéfini.

Exemple d'utilisation : NotreVariable = NotreTableau.Trouver(8);

Les collections génériques peuvent être nettoyées très rapidement, c'est-à-dire supprimer absolument tous les éléments. Pour cela, la méthode est utilisée dégager(), qui supprime les éléments d'un tableau, les chaînes ValeursTable, ou des données d'autres collections.

Méthodes supplémentaires pour Array

Méthode Blimite() renvoie le nombre d'éléments moins un. Ceux. si nous utilisons une boucle Pour, alors au lieu de la méthode Quantité, nous pouvons immédiatement utiliser la méthode La frontière().

En particulier, la variable NumberInArray aurait pu être définie différemment :

NumberInArray = OurArray.InBorder();
Ensuite, lors de la description du cycle lui-même, il ne faut pas soustraire à cette variable.

La méthode Set vous permet d'affecter une valeur à un élément Array par index.

Syntaxe: Installer(,)

Exemple: OurArray.Set(2,8);

Option alternative : NotreTableau = 8 ;

Vous pouvez utiliser la méthode pour un Array Obtenir, afin de lire la valeur à index sans recourir à l'utilisation de crochets.

Syntaxe: Obtenir()

Exemple: NotreVariable = NotreTableau.Get(2);

Option alternative : NotreVariable = NotreTableau ;

Structure de collecte universelle

Une structure, comme un Array, peut avoir un nombre illimité d'éléments, mais le contenu d'un élément diffère d'un Array.

La structure est une collection dont chaque valeur consiste en une paire. Le premier élément d'une paire est appelé Clé. Le deuxième élément de la paire est Sens.

Clé est un type de données strictement chaîne qui décrit une valeur. Par exemple, Clé"Code" peut correspondre à la valeur 113 ; Clé"Nom" signifiant "Vasya". Il n'y a pas de contrainte de type de données sur la valeur elle-même.

La structure est très pratique à utiliser si nous voulons créer une liste de paramètres. Si cela Structure appelé NotreStructure, alors nous nous référerons à ses deux valeurs comme suit : OurStructure.Code et OurStructure.Name.

Un tel appel est beaucoup plus pratique que si nous définissions tous les paramètres dans un Array et y accédions par index.

La structure rend le code du programme lisible (compréhensible). La structure est utilisée assez souvent, beaucoup plus souvent que le Array.

Il est utilisé pour décrire certains paramètres, qui sont souvent assez grands dans tous les algorithmes.

De plus, la Structure est utilisée si la procédure et la fonction contiennent un grand nombre de paramètres passés.

Ensuite, il est beaucoup plus pratique d'écrire tous les paramètres dans la structure et de les transmettre. Ceux. il y a un "packing" de paramètres de procédures et de fonctions.

Par ailleurs, il convient de noter que, comme clé absolument aucune chaîne ne peut apparaître dans la structure. Certaines restrictions s'appliquent.

Clé doit servir d'identifiant. Cela signifie qu'en clé il ne doit pas y avoir d'espaces et il ne peut pas commencer par un chiffre.

Démarrage autorisé clé avec une lettre ou un trait de soulignement. De cette façon, Clé doivent satisfaire aux exigences de création d'identifiants.

Notons en quoi la structure diffère du tableau. La structure a une méthode Insérer, Array a deux méthodes d'insertion : Insérer(à une certaine position) et Ajouter(en fin de liste). Dans un tableau, tous les éléments sont ordonnés.

Une structure est une sorte d'ensemble non ordonné. C'est pourquoi il n'y a qu'une méthode d'insertion pour un Struct.

La valeur est insérée non pas à une position spécifique, mais dans l'ensemble spécifié. Un Struct ne peut pas être référencé par index comme d'autres collections génériques.

Les éléments de la Structure ne sont désignés que par le nom de la Clé. Cependant, la boucle For each of fonctionne également pour la structure, mais vous ne devez pas vous fier à l'ordre des éléments de la structure.

Une structure est créée de la même manière que les autres collections génériques à l'aide du constructeur New, en spécifiant le type de données de Structure.

Comme un Array, le constructeur d'un Struct peut avoir des paramètres. Ceux. il est possible de décrire le contenu de la Structure elle-même à l'aide d'un constructeur.

Contrairement à un tableau, où vous pouvez simplement spécifier le nombre d'éléments pour toutes les dimensions, dans une structure, il est possible de définir le contenu lui-même.

Par exemple: NotreStructure = Nouvelle Structure("Code,Nom", 133, "Vasya");

Tout d'abord, les noms des clés sont répertoriés séparés par des virgules, puis, respectivement, dans le même ordre, les valeurs des paramètres.

Pour ajouter une nouvelle valeur à la Structure, il existe une méthode Insérer, qui insère une nouvelle paire (Clé et Valeur).

Par exemple: OurStructure.Insert("Membres de la famille",3);

La structure se caractérise par une autre méthode qui est utilisée assez souvent. C'est la méthode Propriété.

Grâce à cette méthode, vous pouvez comprendre s'il existe un tel élément dans cette Structure, dont la Clé porte tel ou tel nom.

Si un tel élément existe, le système renverra True, sinon il renverra False.

Par exemple, l'expression OurStructure.Property ("Membres de la famille") sera égal à Vrai. Cette méthode est utilisée assez souvent dans l'analyse de la structure.

Comme pour toute collection universelle, il est permis d'accéder aux propriétés de la Structure par index. Mais l'index de la structure est une valeur de chaîne.

Par exemple: Report(OurStructure["Family Members"]);

Cependant, il ne faut pas oublier qu'une Structure n'est pas un ensemble ordonné d'objets, c'est pourquoi la référence par l'indice 0, 1, 2 n'est pas autorisée.

Liste de valeurs de collection générique

Liste de valeurs est une liste linéaire d'éléments de n'importe quel type de données.

Chaque élément est composé de plusieurs valeurs. Schématiquement, une liste de valeurs peut être représentée sous la forme d'une liste à quatre colonnes.

Première colonne - marque. Il a un type de données booléen et permet à l'utilisateur de cocher ou de décocher les cases.

L'autre colonne est une image qui peut en quelque sorte représenter visuellement cet élément, c'est-à-dire faire correspondre cette ligne avec n'importe quelle image.

La troisième colonne est la valeur stockée elle-même, c'est-à-dire il s'agit de n'importe quel type de données, et il peut être différent dans différentes lignes.

La quatrième colonne est la vue, c'est-à-dire c'est une description de chaîne de la valeur donnée. La vue sera affichée à l'utilisateur lorsqu'il visualisera cet élément. Dans ce cas, si la vue n'est pas définie, le système essaiera d'obtenir des vues pour l'élément contenu dans cette position.

Liste de valeurs- c'est l'objet avec lequel l'utilisateur peut travailler visuellement. Ceux. Liste de valeurs peuvent être affichés sur le formulaire.

L'utilisateur peut effectuer certaines actions avec. Outre, Liste de valeurs peuvent être déduits indépendamment à l'aide de méthodes, c'est-à-dire afficher à l'écran dans certaines branches de l'algorithme (sauf pour code serveur) afin que l'utilisateur sélectionne une ligne ou coche certaines cases.

Allons trouver Liste de valeurs dans l'aide de sitax. Constructeur Liste de valeurs non paramétrable (aucune valeur par défaut ne peut être définie).

Il existe des méthodes comme :

• Insérer(,) ;
• Ajouter(,);
• Quantité();
• Indice().

Il existe également des méthodes spéciales, par exemple, DéchargerValeurs(). Cela crée un tableau dans lequel la liste de valeurs est copiée. Par exemple:

ArrayElements = ListPriceTypes.UnloadValues();

Il existe aussi une méthode inverse :
PriceTypeList.LoadValues(ElementsArray);

Il existe des méthodes de recherche :
FindByValue(); FindByIdentifier().

Il existe une méthode de copie :
CopyList = ListPriceTypes.Copy();
Cette méthode est destiné à apporter une sorte de modification avec une copie.

Il existe des méthodes :
SortByValue();
TrierParVue().

Méthodes Sélectionnez l'élément(,) et Marquer les éléments () appeler une boîte de dialogue modale qui arrête l'exécution de l'algorithme jusqu'à ce que l'utilisateur ferme cette fenêtre.

Pour utiliser ces méthodes dans les propriétés de configuration Mode d'utilisation de la modalité doit être réglé sur Utilisation.

Exemple de code appelé à partir d'un module d'application gérée :

Affichez ce code en mode utilisateur (boîte de dialogue modale).

Dessous Liste de valeurs utilisé comme type de données disponible pour l'attribut de formulaire. Nous créons un nouvel attribut pour le formulaire de traitement, déterminons son type Liste de valeurs et affichez-le sur le formulaire.

Nous créons nouvelle équipe StoreGifts, transférez-le dans le formulaire et définissez un gestionnaire d'action pour celui-ci.

En mode utilisateur, lorsque vous cliquez sur le bouton Remplir les cadeaux dans le formulaire de traitement, une liste complétée apparaîtra.

Si vous le souhaitez, la liste peut être modifiée : ajoutez des éléments, en supprimez d'autres.

Conformité de collecte universelle

Cette collection ressemble beaucoup à structure. Tout comme un Struct, un Match est un ensemble de valeurs composé d'une clé et de la valeur elle-même.

La principale différence est que n'importe quel type de données peut être spécifié en tant que clé, ainsi que pour une valeur. Compte tenu de cette fonctionnalité, il est nécessaire d'accéder à la valeur de correspondance par index, la valeur clé est spécifiée comme valeur d'index.

La clé peut être un type de données autre qu'une chaîne. Les propriétés et les méthodes de travail avec Matching sont presque les mêmes que celles de la Structure.

Le Match Constructor, contrairement à un Struct, ne contient pas la possibilité de spécifier des paramètres.

Exemple d'utilisation :

La correspondance est utile lorsqu'il est nécessaire de relier deux structures quelconques. Par exemple, chaque ligne de la partie tabulaire doit correspondre à une ligne du tableau des valeurs.
Dans ce cas, la ligne de la section tabulaire est utilisée comme clé de correspondance et la valeur correspondante est indiquée.

Lors de l'insertion d'éléments dans une collection Match autre que la méthode Insérer(,) Il existe une autre façon d'insérer une valeur, et c'est d'utiliser l'opérateur d'affectation normal.

Par exemple: OurMatch = Nouvelle correspondance ;
Correspondance = 999 ;

Ceux. si l'élément n'était pas présent dans la collection, alors il sera ajouté à l'aide de l'opérateur d'affectation, et s'il est présent, il sera mis à jour.

Ceci est différent de Structure.

Tableau des valeurs de la collection générique

Tableau des valeurs est une table avec un nombre arbitraire de lignes et un nombre arbitraire de colonnes. Une intersection peut stocker des valeurs de n'importe quel type de données. Si nécessaire, les colonnes peuvent être typées, c'est-à-dire déterminer dans quelle colonne quel type de données est stocké.

Vous pouvez laisser les colonnes non typées, puis la même colonne dans différentes lignes peut stocker des valeurs de types différents.

Différences ValeursTableà partir d'un tableau 2D :

• c'est un objet avec lequel l'utilisateur peut travailler (le tableau des valeurs peut être affiché à l'écran, l'utilisateur peut le remplir, à l'avenir les données saisies peuvent être lues);
• création d'index pour une recherche rapide ;
• clonage, remplissage de la colonne entière avec une certaine valeur, déchargement de toutes les colonnes dans un tableau.

Tableau des valeurs utilisé comme une sorte de tampon pour stocker des informations. Tableau des valeurs est renvoyé et accepté comme paramètre par de nombreuses méthodes du système. Il est possible de construire une requête vers le tableau des valeurs.

Alors, Tableau des valeurs se compose d'un ensemble de lignes et d'un ensemble de colonnes. Les lignes et les colonnes sont des collections.

Ceux. à l'intérieur de la collection Tableau des valeurs il y a deux autres collections. Passons à l'assistant de syntaxe et trouvons Tableau des valeurs.

Types de données pris en charge : lui-même Tableau des valeurs, composé de chaînes. Chaque ligne est représentée par un type de données RowTableValues, qui a ses propres propriétés et méthodes. Disponible CollectionColumns TableValues possède également certaines propriétés.

Point important! La procédure qui génère Tableau des valeurs, devrait compiler & OnServer.

Avant de commencer à travailler avec Tableau des valeurs, vous devez déterminer quelles colonnes il contiendra (c'est-à-dire les créer). Syntaxe:

Ajouter(,)
(optionnel)
Tapez : Chaîne.
(optionnel)
Type : Types de description
(optionnel)
Tapez : Chaîne.
(optionnel)
Tapez : Nombre.

Par exemple:

Pour appeler cette procédure, nous allons utiliser la commande.

Dans le descriptif ValeursTable car les éléments de la collection sont exactement RowsTableValues.

Contrairement aux colonnes, qui se composent uniquement de propriétés (Nom, Type, Titre, Largeur), dans RowTableValues il existe à la fois des propriétés (référence par nom de colonne) et des méthodes (vous pouvez obtenir et définir une valeur, travailler avec les propriétaires).

Ajouter nouvelle ligneà la table, vous devez utiliser la méthode soit Ajouter(), ou Insérer(). Dans le second cas, vous devez spécifier la position dans laquelle la chaîne requise doit être placée.

Pour attribuer une valeur à une colonne, nous y faisons référence par le nom ou l'index de la colonne (entre crochets) séparés par un point.

Pour remplissage ValeursTable les méthodes suivantes peuvent être utilisées :

dégager()- pour supprimer toutes les lignes de ValeursTable.

RemplirValeurs(,)– vous permet de remplir toutes les colonnes ou les colonnes sélectionnées avec une seule valeur.
ChargerColonne(,)– charge une colonne à partir d'un tableau.
DéchargerColonne()– décharge une colonne dans un tableau.

Les deux dernières méthodes sont utiles lorsque vous devez déplacer une colonne d'un tableau de valeurs à un autre.

Copie(,)- vous permet de créer une nouvelle table basée sur une table existante Tableau des valeurs, tout en spécifiant non pas toutes les lignes et toutes les colonnes, mais seulement certaines d'entre elles. Valeur de retour - Tableau des valeurs.

Vous pouvez copier la structure ValeursTable. Il existe une méthode correspondante pour cela. CopierColonnes(). Nous recevrons un vide Tableau des valeurs avec la structure souhaitée.

À Tableau des valeurs il y a une méthode total(). Vous pouvez spécifier la colonne dans laquelle vous souhaitez additionner les valeurs numériques. En ce qui concerne le code affiché précédemment dans le Tableau, vous pouvez calculer la valeur : TK.Total ("Somme").

À Tableau des valeurs il est possible de regrouper (effondrer) des valeurs numériques par les mêmes valeurs de certaines colonnes à l'aide de la méthode Effondrement(,).

En ce qui concerne le code affiché précédemment dans le Tableau, vous pouvez calculer la valeur : TK.Collapse("Jour de la semaine", "Montant").

Tableau des valeurs peut être affiché sur l'écran de l'utilisateur afin que vous puissiez effectuer toutes les actions avec. Mais contrairement à Liste de valeursà partir du code du programme, vous ne pouvez pas simplement appeler la table à l'écran.

Afficher Tableau des valeursà l'écran, créez un attribut de formulaire et attribuez-lui un type de données Tableau des valeurs.

Après cela, le tableau résultant doit être affiché sur le formulaire.

Dans le module formulaire, à la fin de l'algorithme précédemment compilé (dans la Procédure de création d'un tableau de valeurs), ajoutez :
ValueVFormData(TK, Table);

Arbre de valeurs de collection générique

une collection polyvalente qui ressemble beaucoup à Tableau des valeurs. La différence avec le tableau est que les lignes de l'arbre peuvent être subordonnées les unes aux autres, c'est-à-dire une sorte de hiérarchie peut se former.

Il peut également être affiché à l'écran. L'arborescence de valeurs consiste explicitement en une collection de lignes et une collection de colonnes. Il y a deux propriétés dans l'arborescence, Rows et Columns.

Étant donné que les lignes peuvent être subordonnées les unes aux autres, un parent peut être spécifié pour chaque ligne, ainsi que des lignes qui lui sont subordonnées.

Créons la commande Tree appropriée et sa procédure de traitement.

créons dans lequel il y a une ligne parente et deux lignes subordonnées.

Créer un attribut de formulaire DerZn(type de données - Arbre de valeurs).

Pour cet attribut, nous allons créer les colonnes Année et Mois.

Déplacer l'élément correspondant DerZn au formulaire.

À la fin Procédures TreeOnServer() ajouter:

ValueVFormData(TreeZn, DerZn);

Vérifions ce qui s'est passé en mode utilisateur.

Avec bouton Ajouter vous pouvez ajouter de nouvelles lignes. Ils peuvent également former une hiérarchie.

Pour itérer sur tous les éléments de l'arbre de valeurs, nous devons utiliser la récursivité, c'est-à-dire appeler une procédure à partir d'elle-même. Par exemple, le traitement d'un arbre de valeurs pourrait ressembler à ceci :

Ceci conclut notre première introduction aux collections universelles.

Dans le prochain article, nous verrons quel mécanisme important un développeur peut utiliser pour simplifier l'accès à un élément du dictionnaire à partir du code du programme.

Dans cette unité, nous nous familiariserons avec un nouveau type de données du langage 1C, appelé Liste de valeurs.

Liste de valeurs est un tableau, mais avec plus de fonctionnalités. Et si c'est le cas, alors c'est aussi une collection de données et vous pouvez y mettre un ensemble de nombres :

// créé une liste de valeurs

List.Add(23);

Jusqu'à présent, tout ressemble beaucoup à un tableau, n'est-ce pas ? Mais passons à autre chose. Pour maintenant afficher ces nombres à l'utilisateur, on écrit :

// Boucle sur chaque élément de la liste For Each Element From List Loop Report(Item.Value);

// affiche la valeur de l'élément EndCycle ;

Et voici la première différence. Les éléments d'un tableau ordinaire sont les nombres eux-mêmes. Et accès à la valeur courante de l'élément liste nous obtenons avec option Sens, en utilisant la construction Élément. Sens.

Considérez quelques fonctionnalités supplémentaires Valeurs.

Peut trier

Par exemple, nous pouvons facilement trier une liste de valeurs. La liste peut le faire par elle-même :

List.SortByValue(SortingDirection.Asc); Dans le cas d'un tableau ordinaire, il faudrait implémenter l'un des algorithmes de tri (par exemple, "bulle").

Peut rechercher

La liste de valeurs est capable de rechercher ses propres éléments. Disons que nous voulons savoir si le numéro entré par l'utilisateur est dans notre liste :

EntrezNombre(Nombre); // a saisi un nombre de l'utilisateur FoundItem = List. FindByValue(Number);

If FoundItem = Undefined Then OpenValue("Number " + Number + " not found in the list!"); Autrement

OpenValue("Number " + Number + " est dans la liste. La voici :" + FoundItem.Value);

Fin si; Liste de valeurs

Prend en charge l'insertion et la suppression

Une liste de valeurs, comme un tableau, prend en charge l'insertion et la suppression d'éléments :

Liste. Insérer(0, 1000);

// insère un millier au tout début de la liste List.Delete(O); // et le supprimer immédiatement de la liste List. Insérer(Liste.Quantité(), 13);

// insère 13 à la fin de la liste Report(List[List.Count() - 1]);

// affiche le dernier élément de la liste (13)

Prend en charge les crochets

Comme vous l'avez déjà compris, la numérotation des éléments de la liste commence également à zéro, et on peut désigner n'importe quel élément par son index à l'aide de crochets :

Notifier(Liste.Valeur); // déduit le second élément de la liste Ainsi, on peut parcourir tous les éléments de la liste comme ceci :

For A = 0 By List.Quantity() - 1 Loop Report(List[A].Value);

FinCycle ;

Capable de créer une copie

La liste de valeurs a juste une grande opportunité - elle peut créer sa propre copie :

ListCopy = List.Copy();

// fait une copie de la liste // nous pouvons maintenant changer en toute sécurité la copie de la liste // alors que la liste d'origine ne changera pas la copie de la liste. Valeur = 123456 ;

Peut être converti en tableau

Et enfin, vous pouvez facilement décharger tous les éléments de la liste dans un tableau à tout moment :

ArrayNumbers = Liste. DéchargerValeurs();

// déchargé dans un tableau

Pour A = 0 Par ArrayNumbers.Quantity() - 1 Boucle

Report(ArrayNumbers[A]); // pas besoin de spécifier // valeur de l'option

FinCycle ;

Pour élaborer et consolider le matériel de cette unité, il est recommandé d'effectuer la tâche suivante.

Il est nécessaire d'entrer 5 chiffres de l'utilisateur, de trouver le plus grand et le plus petit d'entre eux et de les afficher à l'utilisateur. La solution doit utiliser une liste de valeurs.

La solution

Liste = Nouvelle liste de valeurs ;

// créé une liste de valeurs For A = 1 By 5 Loop Number = 0;

EntrezNombre(Nombre); // entrez un nombre de l'utilisateur List.Add(Number); // et l'ajouter à la liste EndCycle ; // et donc 5 fois

// trie la liste des nombres

Liste. Trier par valeur (sens de tri. Asc);

// après tri, le premier élément de la liste est // le plus petit élément, et le dernier élément est le plus grand OpenValue("Le plus petit élément" + Liste +

", et le plus grand est " + List[List.Count() - 1]);