Probablement, aucun objet des collections universelles de valeurs n'est aussi populaire parmi les développeurs 1C que le tableau des valeurs (TV). Les listes de valeurs ne peuvent pas être étendues avec des détails : l'arbre de valeurs est visuellement pratique à percevoir, mais la conception de la lecture par programme des valeurs de ses lignes est difficile à mettre en œuvre.

Et uniquement le tableau des valeurs :

• Capable de remplir directement des parties tabulaires de documents, d'ouvrages de référence et de traitement ;
• Est le résultat de l’exécution d’une requête ;
• Facile à lire et formulé visuellement ;
• et bien d'autres encore.

Dans cet article, nous avons essayé de donner une idée générale d'un objet aussi complexe et universel qu'une table de valeurs.

De quoi sont constitués les tableaux de valeurs ?

Tous les développeurs débutants savent clairement que la table de valeurs contient :

1. Colonnes décrivant la structure du tableau ;
2. Lignes qui remplissent le tableau d’informations.

Cependant, nous oublions très souvent une propriété importante d'une table - ses index, à savoir que leur utilisation nous permet d'accélérer considérablement le processus de recherche dans la table, d'y former des sélections et d'améliorer considérablement les performances.

Mais tout d’abord.

La figure 1 montre à quoi ressemble un tableau de valeurs, imprimé selon la procédure la plus simple, qui montre leur structure et leur contenu.

Comme le montre l'exemple, le tableau comporte 5 colonnes, sans compter le numéro de ligne dans l'ordre.

Dans la plupart des cas, il n'est pas nécessaire de spécifier le type de données d'une colonne et sa largeur ; il suffit de spécifier le nom de la colonne, mais dans certains cas, cela ne peut tout simplement pas être évité (par exemple, lors du téléchargement d'une table vers un fichier dbf).

Si vous envisagez d'utiliser la table de valeurs comme source de données pour une requête à l'avenir, il est nécessaire de spécifier le type de données (Fig. 2).

L'ajout d'une ligne s'effectue à l'aide de la méthode Add(), attribuant le nom de la nouvelle ligne.

Index des tableaux de valeurs

La recherche dans le tableau des valeurs s'effectue selon deux méthodes :

• Rechercher (renvoie le premier élément trouvé en fonction de certains paramètres, sinon la valeur est Indéfinie) ;
• FindRows (renvoie un tableau de lignes de tableau qui remplissent certaines conditions).

La recherche dans de grandes tables ralentit considérablement le système et peut prendre beaucoup de temps. C'est dans ces cas qu'il convient d'utiliser les index.

Dans le premier cas, la recherche s'effectue à l'aide d'une valeur et d'une colonne, ce qui doit être transféré vers les index (Fig. 3)

Les index passés séparés par des virgules indiquent que la table peut être recherchée à l'aide de la méthode FindRows, à laquelle une certaine structure sera passée en paramètre.

Dans le cas donné dans l'exemple, la deuxième ligne indique une recherche simultanée de lignes contenant une valeur de Nomenclature spécifique et ses caractéristiques, et la troisième ligne indique que le document « Ordre de Production » peut être ajouté aux paramètres de recherche.

Lorsque vous travaillez avec divers objets de métadonnées de configuration, ainsi qu'avec des rapports et des traitements, une situation se présente souvent lorsqu'il est nécessaire d'effectuer certaines actions avec leurs parties tabulaires. Travailler directement avec des éléments de formulaire ou des parties tabulaires de documents n'est pas toujours pratique.

C'est là que le tableau des valeurs vient à nouveau à la rescousse. Dans la spécification technique, en utilisant la méthode des parties tabulaires Unload(), vous pouvez :

1. Répétez complètement la structure du tableau du document, en préservant toutes les informations possibles ;
2. Déterminez uniquement les colonnes et les lignes nécessaires à la poursuite du travail et affichez-les.

L'action inverse (remplissage de la partie table) s'effectue à l'aide de la méthode Load() dont le seul paramètre est le nom de la table à afficher.

Il est à noter que la comparaison des colonnes de la partie tabulaire et de la mission technique s'effectue par nom.

Vous pouvez copier complètement un savoir traditionnel sur un autre, ainsi que déterminer quelles lignes et colonnes seront transférées à l'aide de la méthode Copy().

Figure 4

Dans ce cas, les colonnes du tableau seront conservées et les informations et lignes du doublon seront supprimées.

Table de valeurs et requête

Comme mentionné ci-dessus, le résultat de l'exécution d'une requête est téléchargé dans la spécification technique, mais bien souvent les développeurs se posent une question : comment traiter une table de valeurs avec une requête, est-ce possible et quel code permet de le faire.

La technologie de requête dans 1C n'implique pas l'utilisation de spécifications techniques comme sources de données, mais cette limitation peut facilement être contournée en utilisant. Le code de la figure 5 montre comment cela est effectué.

Figure 5

En remplaçant « * » par les noms des colonnes (une ligne du formulaire TZ.Nomenclature), vous pouvez réduire la quantité d'informations téléchargées.

Une erreur lors de l'exécution d'une requête (Fig. 5) « Le type ne peut pas être traité dans la requête » indique que le développeur a oublié d'exécuter une partie du code de la Fig. 2 et n'a pas tapé les colonnes.

Table de valeurs et boucles

Lors de l'itération sur les lignes d'un tableau de valeurs à l'aide d'une méthode contenant un compteur (Fig. 6), il est important de se rappeler que la valeur initiale de l'index de ligne est 0 et que la valeur finale de l'itérateur doit être 1. inférieur au nombre de lignes du tableau. Sinon, il y a 100 % de chances qu'une erreur « La valeur de l'indice est hors plage »

Figure 6

En général, il est préférable d'énumérer les lignes de spécifications techniques à travers la construction « Pour chaque... de », définissant le nom de l'itérateur.

Afin de comptabiliser l'argent et les biens, divers tableaux sont largement utilisés dans les affaires. Presque tous les documents sont un tableau.

Un tableau répertorie les marchandises à expédier depuis l'entrepôt. Un autre tableau montre les obligations de payer pour ces biens.

Par conséquent, en 1C, le travail avec des tableaux occupe une place prépondérante.

Les tableaux en 1C sont également appelés « parties tabulaires ». Les répertoires, documents et autres en ont.

La requête, une fois exécutée, renvoie une table accessible de deux manières différentes.

La première sélection - plus rapide -, l'obtention de lignes à partir de celle-ci n'est possible que dans l'ordre. La seconde consiste à télécharger le résultat de la requête dans une table de valeurs, puis à y accéder de manière aléatoire.

//Option 1 – accès séquentiel aux résultats de la requête

//récupère le tableau
Sélectionner = Query.Run().Select();
// on parcourt toutes les lignes du résultat de la requête dans l'ordre
Boucle While Select.Next()
Rapport (Sélection.Nom);
Fin du cycle ;

//Option 2 – téléchargement vers une table de valeurs
Requête = Nouvelle requête("SELECT Nom FROM Directory.Nomenclature");
//récupère le tableau
Tableau = Requête.Run().Unload().
//de plus, nous pouvons également parcourir toutes les lignes
Pour chaque ligne du cycle de table
Rapport (String.Name);
Fin du cycle ;
//ou accéder arbitrairement aux chaînes
Row = Table.Find("Pelle", "Nom");

Une caractéristique importante est que dans le tableau obtenu à partir du résultat de la requête, toutes les colonnes seront strictement typées. Cela signifie qu'en demandant le champ Nom au répertoire Nomenclature, vous recevrez une colonne de type String avec une longueur autorisée ne dépassant pas N caractères.

Tableau sur le formulaire (client gros)

L'utilisateur travaille avec le tableau lorsqu'il est placé sur le formulaire.

Nous avons discuté des principes de base du travail avec des formulaires dans la leçon sur et dans la leçon sur

Alors, plaçons le tableau sur le formulaire. Pour ce faire, vous pouvez faire glisser le tableau depuis le panneau Contrôles. De même, vous pouvez sélectionner Contrôle Formulaire/Insertion dans le menu.

Les données peuvent être stockées dans la configuration - vous devez alors sélectionner la partie tabulaire existante (précédemment ajoutée) de l'objet de configuration dont vous modifiez le formulaire.

Cliquez sur le bouton "..." dans la propriété Données. Afin de voir la liste des parties tabulaires, vous devez développer la branche Objet.

Lorsque vous sélectionnez la partie tabulaire, 1C lui-même ajoutera des colonnes au tableau du formulaire. Les lignes saisies par l'utilisateur dans un tel tableau seront automatiquement enregistrées avec l'ouvrage/document de référence.

Dans la même propriété Data, vous pouvez saisir un nom arbitraire et sélectionner le type de table de valeurs.

Cela signifie qu'un tableau de valeurs arbitraire a été sélectionné. Il n'ajoutera pas automatiquement de colonnes ni ne sera automatiquement enregistré, mais vous pouvez en faire ce que vous voulez.

En faisant un clic droit sur le tableau, vous pouvez ajouter une colonne. Dans les propriétés d'une colonne, vous pouvez préciser son nom (pour référence dans le code 1C), l'en-tête de la colonne sur le formulaire, le lien avec l'attribut de la partie tabulaire (cette dernière - si ce n'est pas un tableau arbitraire qui est sélectionné, mais un partie tabulaire).

Dans les propriétés du tableau du formulaire, vous pouvez spécifier si l'utilisateur peut ajouter/supprimer des lignes. Un formulaire plus avancé est la case à cocher Afficher uniquement. Ces propriétés sont pratiques à utiliser pour organiser des tableaux destinés à afficher des informations, mais pas à les éditer.

Pour gérer le tableau, vous devez afficher un panneau de commande sur le formulaire. Sélectionnez l'élément de menu Formulaire/Insérer un contrôle/Barre de commandes.

Dans les propriétés de la barre de commandes, cochez la case Remplissage automatique pour que les boutons du panneau apparaissent automatiquement.

Tableau sur formulaire (client léger/géré)

Sur un formulaire géré, ces actions sont un peu différentes. Si vous devez placer une partie tabulaire sur le formulaire, développez la branche Objet et faites glisser l'une des parties tabulaires vers la gauche. C'est tout!

Si vous devez placer une table de valeurs, ajoutez un nouvel attribut de formulaire et dans ses propriétés spécifiez le type – table de valeurs.

Pour ajouter des colonnes, utilisez le menu contextuel sur cet attribut de formulaire, sélectionnez Ajouter une colonne d'attribut.

Ensuite, faites également glisser le tableau vers la gauche.

Pour qu'un tableau ait une barre de commandes, dans les propriétés du tableau, sélectionnez les valeurs dans la section Utilisation – Position de la barre de commandes.

Télécharger un tableau vers Excel

N'importe quel tableau 1C situé sur le formulaire peut être imprimé ou téléchargé sur Excel.

Pour ce faire, faites un clic droit sur un espace vide du tableau et sélectionnez Liste.

Dans un client (léger) géré, des actions similaires peuvent être effectuées à l'aide de l'élément de menu Toutes les actions/Afficher la liste.

Salutations à tous les lecteurs d'infostart. Cet article sera consacré à la question de la création d'une table de valeurs arbitraire sous la forme d'une application gérée par programme.

Caractéristiques de la tâche.

Quiconque a programmé dans une application standard a souvent été confronté à la tâche d'obtenir un tableau de valeurs arbitraire sur un formulaire. Un tableau de valeurs arbitraire est un tableau dont le nombre et le type de colonnes ne sont pas connus à l'avance. C'est-à-dire qu'il peut y avoir 3 colonnes, ou peut-être 6, ou peut-être 8. Dans une application normale, tout est simple : vous pouvez placer l'élément « Table des valeurs » sur le formulaire de traitement, puis transférer la table de valeurs créée ​à cet élément par programmation. Puis avec une simple commande :

Formulaire Elements.TableField.CreateColumns();

obtenez un tableau de valeurs prêt à l'emploi sur le formulaire. Il semblerait que cela puisse être plus simple.

Tout cela était dans l'application régulière. Dans une application gérée, tout a changé. Ce n'est pas si simple de créer un tableau arbitraire. Vous devez maintenant soit paramétrer de manière rigide la table de valeurs sur le formulaire, soit la créer par programme (décrivez, eh bien, c'est en fait l'essence de l'application gérée elle-même). C'est ce que nous allons essayer de faire : créer par programme une table de valeurs arbitraire sur un formulaire contrôlé.

La solution du problème.

La première chose que nous devons faire est de déterminer comment le tableau apparaîtra sur le formulaire. L’essentiel est que vous n’avez pas besoin de créer d’élément de formulaire lors du traitement. Nous allons le créer par programme, comme le tableau entier. Autrement dit, le tableau sera décrit et créé au moment de l'ouverture du formulaire ou à l'aide d'un bouton - selon qui en a besoin.

La création d'une table sur le formulaire se fait via la description de la table de valeurs en tant qu'attribut :
SelectionTypeArray = Nouveau tableau ; Tableau de SelectionType.Add(Type("Value Table")); ChoiceTypeDescription = Nouveau TypeDescription (ChoiceTypeArray); Tableau de détails = Nouveau tableau ; Tableau d'attributs.Add (Nouveaux attributs de formulaire ("Tableau de planification", Description du type de sélection, "", "TZN")); Nous devons maintenant créer une table programmatique de valeurs contenant les données. Si le tableau des valeurs est obtenu à partir d'une requête, alors tout est plus ou moins en ordre. Si le tableau est créé manuellement, la signification des colonnes qui contiendront des nombres ou des dates peut être créée via la « Description des types ». Le fait est que les colonnes du tableau des valeurs doivent avoir un certain type. Si, par exemple, on s'attend à ce que l'utilisateur remplisse les données de ces colonnes de manière interactive, alors vous ne pouvez pas ajouter une colonne de la table de valeurs simplement avec un nom ; elle doit avoir un type. Gardez à l’esprit : c’est très important parce que... Nous transférerons ces types dans le tableau du formulaire.
Nous créons un tableau qui contient plusieurs colonnes :
CD = NewDateQualifiers(DateParts.Time); ArrayKD = Nouveau tableau ; ArrayCD.Add(Type("Date")); DescriptionTypesTime = Nouveaux DescriptionTypes (ArrayCD,CD); TZ = Nouvelle Table de Valeurs ;
TK.Columns.Add("Avec", DescriptionTypesTime);
TK.Columns.Add("Avant", DescriptionTypesTime);
TK.Columns.Add("Nom");
TK.Columns.Add("Note"); // Nom complet et note - lignes Ensuite, nous remplirons notre table de programme TK avec les données nécessaires. Nous recevons une table TK qui contient les valeurs nécessaires et est prête à être transférée vers l'attribut de formulaire créé. Pour chaque colonne de TK. Cycle de colonnes

Tableau d'attributs.Add (nouveaux attributs de formulaire (Column.Name, Column.ValueType, "ScheduleTable"));

Fin du cycle ;
ChangeDetails(ArrayDetails);
SelectionFieldsTable = Elements.Add("TZN", Type("FormTable"));
SelectionFieldsTable.DataPath = "ScheduleTable";
SelectionFieldTable.Display = TableDisplay.List ;

C'est une combinaison simple et notre table est prête.

Pour chaque colonne de TK. Cycle de colonnes

NewElement = Elements.Add(Column.Name, Type("FormField"), SelectionFieldTable);
NewElement.View = FormFieldView.InputField ;
NewElement.DataPath = "ScheduleTable." + Colonne.Nom ;
NewElement.Width = 10 ;

Fin du cycle ;

Conception conditionnelle, si nous en avons besoin, nous l'écrivons également manuellement, le menu de commande - manuellement. Les gestionnaires de table sont également écrits à la main. Par exemple, pour ajouter un gestionnaire d'événements pour la table « Sélection » :

Tableau de SelectionFields.SetAction("Selection","TZNSelection");

Pour traiter cet événement, une procédure distincte est prescrite sous la forme d'une procédure :

&SurClient
Procédure TKNSelection(TK, SelectedRow, Field, StandardProcessing)
//commandes du gestionnaire EndProcedure

Notez que les gestionnaires de tables se déclenchent sur le client et doivent donc disposer d'une commande de pointeur du compilateur.

&SurClient

Eh bien, la dernière chose que je voulais ajouter est qu'après toutes ces étapes, n'oubliez pas de transmettre la table terminée à l'attribut form :

ValueВFormAttributes(ToR, "ScheduleTable");

Voilà ce que nous avons comme résultat :

Et voici la gestion de l'événement "Sélection" :

Épilogue.

J'espère que l'article aidera les programmeurs 1C qui commencent à créer des tableaux sur un formulaire par programme.

Vous pouvez télécharger un traitement qui crée par programme une table de valeurs et l'affiche sur un formulaire gérable avec des commentaires qui vous aideront à créer vos propres tables.

Il existe deux méthodes spéciales pour rechercher une table de valeurs :

1. Trouver

TVHorizon = Directories.Nomenclature.FindByName("TVHorizon");
FoundString = TZNomenclature.Find(TVHorizon);
//nous pouvons également spécifier dans quelles colonnes rechercher pour accélérer la recherche
FoundString = TZNomenclature.Find(TVHorizon, "Nomenclature");

Cette méthode renvoie la première ligne trouvée avec la valeur souhaitée, ou Undefined si elle ne la trouve pas. Par conséquent, il est pratique de l’utiliser pour rechercher des valeurs uniques, car sinon, lorsqu'une valeur est trouvée, vous devrez la supprimer du tableau afin de trouver la suivante.

Pour éviter ce problème, il existe la méthode suivante qui vous permet de trouver un tableau de chaînes correspondantes :

2. Rechercher des chaînes

Sélection Structure.Insert("Nomenclature", TVHorizon); // indique d'abord la colonne où chercher, puis quoi rechercher.

Cette méthode renvoie toujours un tableau, mais il peut être vide si rien n'est trouvé. Et cette méthode, comme la précédente, renvoie les lignes du tableau de valeurs elles-mêmes, et non les valeurs elles-mêmes dans un tableau séparé. Par conséquent, en modifiant les valeurs dans la chaîne du tableau ou, comme dans la méthode précédente, pour la chaîne trouvée, vous modifierez la valeur dans le tableau des valeurs traité.

Un autre avantage de cette méthode est qu'elle peut effectuer une recherche dans plusieurs colonnes de la table de valeurs à la fois :

SelectionStructure = Nouvelle structure ;
Sélection Structure.Insert("Nomenclature", TVHorizon);
Structure de sélection.Insert("Quantité", 10);
FoundArray de lignes = TZNomenclature.FindLines(SelectionStructure);

Le seul point négatif, comme vous pouvez le constater, est que vous ne pouvez pas utiliser d’autres types de comparaison que « égal »