Comment utiliser une classe spécifique en JavaScript pour compter les cellules d'un tableau

Déclencher un modal avec un nombre de classes actives dans une table

Vous souhaiterez peut-être appliquer un comportement personnalisé basé sur le contenu de chaque cellule lorsque vous travaillez avec . Par exemple, vous pouvez utiliser des modèles ou des critères spécifiques pour attribuer dynamiquement des classes aux cellules du tableau. Votre tableau peut ainsi devenir plus utile et attrayant.

Dans cet exemple, les cellules de tableau qui satisfont à certaines exigences auront une classe nommée leur a été ajouté. UN une fonction qui examine chaque cellule, vérifie son contenu, puis applique la classe de manière appropriée est utilisée pour ce faire. C'est une méthode productive pour organiser des cellules particulières en fonction de leurs données.

Après avoir appliqué le classe à un sous-ensemble de cellules, compter le nombre de cellules qui ont cette classe pourrait être une prochaine étape fréquente. Si vous souhaitez démarrer un événement ou une action, comme ouvrir un modal qui affiche le décompte, compter ces cellules peut être très utile.

Ce tutoriel va vous apprendre à utiliser JavaScript pour compter le nombre de cellules qui ont le classe et de lancer automatiquement un modal qui affiche le décompte. En utilisant , la solution est simple, efficace et simple à mettre en œuvre.

Commande	Exemple d'utilisation
.each()	Chaque élément d'un ensemble d'éléments correspondants est itéré par cette fonction jQuery. Il applique une logique conditionnelle ou des classes en itérant sur chaque cellule du tableau (	) in our example.
ajouterClass()	The selected items receive one or more class names added to them by this jQuery method. The script applies the ou classer les cellules en fonction de leur contenu.
.dialogue()	Used with jQuery UI to generate a modal dialog. When the script triggers the modal, the autoOpen: true option makes sure it opens automatically and shows the number of active items.
.texte()	The text content of the chosen components is retrieved or set using this technique. In this instance, it checks to see if the contents of every	la cellule correspond à un modèle particulier.
RegExp()	Les expressions régulières sont créées avec ce constructeur JavaScript. Le script peut attribuer des classes en fonction du contenu en identifiant des modèles tels que ou .
classList.add()	Cette technique JavaScript de base donne à un élément une classe particulière. Il fonctionne de manière similaire à addClass() de jQuery dans la solution JavaScript Vanilla, en ajoutant le ou classe selon les conditions.
DOMContentLoaded	Lorsque le document HTML a terminé son chargement et son analyse, l'événement DOMContentLoaded est déclenché. Dans l'exemple JavaScript Vanilla, il garantit que le script s'exécute une fois le chargement du DOM terminé.
querySelectorAll()	Chaque élément du document qui correspond au sélecteur CSS donné est renvoyé par cette fonction JavaScript. Dans l'exemple JavaScript de base, il est utilisé pour sélectionner chaque	element in the table for further processing.
pourChaque()	An array method in JavaScript that lets you iterate over elements. Here, it's utilized to iterate over every table cell that querySelectorAll() returned and apply the required logic to each one.

Comprendre le script : compter les cellules et déclencher un modal

Dans le premier exemple de script, chaque cellule du tableau est itérée, son contenu est évalué et une classe est attribuée en fonction de l'évaluation à l'aide de . Cette fonctionnalité est rendue possible en parcourant chacun des

Avec le constructeur, une expression régulière pour faire correspondre les nombres suivis de lettres est construite. Cette technique garantit que les cellules contenant des données telles que « 1A » ou « 3C » sont reconnues et étiquetées avec la classe actuelle. La cellule reçoit une classe distincte appelée si le contenu correspond à un modèle différent, tel "c" suivi d'un nombre. Cela permet de classer plus précisément les données dans le tableau. Par ailleurs, le La méthode garantit que les cellules peuvent avoir ces classes ajoutées sans supprimer les classes qu'elles pourraient déjà avoir.

L'étape suivante consiste à compter les cellules appropriées et à lancer un modal après qu'elles aient toutes été étiquetées avec la classe active. Chaque fois qu'une cellule obtient la classe active, le décompte est incrémenté et enregistré dans une variable nommée . Le nombre de cellules admissibles dans le tableau doit être déterminé à l'aide de ce décompte. En utilisant le fonction de jQuery UI, un modal est généré lorsque le comptage est terminé. Le L'attribut permet au modal de s'ouvrir automatiquement. Le nombre de cellules actives est affiché à l'intérieur du modal.

Dans le second cas, Vanilla JavaScript est utilisé pour dupliquer la même procédure. est utilisé à la place de jQuery dans cette approche pour sélectionner toutes les cellules du tableau, et un simple la boucle parcourt chaque cellule. Les expressions régulières sont utilisées pour correspondre au contenu de la cellule, tout comme dans la solution jQuery. Si une correspondance est découverte, activeCount est mis à jour et la classe active est ajoutée à l'aide du méthode. En fin de compte, la modification du code HTML interne d'un élément modal prédéfini dans le DOM active le modal. Le même résultat que l'exemple jQuery est obtenu en utilisant cette solution, qui ne repose pas sur des bibliothèques externes.

$(document).ready(function() {
  var activeCount = 0;
  $('td').each(function() {
    var $this = $(this);
    if ($this.text().match(new RegExp(/[0-9][A-Z]/)) !== null) {
      $this.addClass('active');
      activeCount++;
    }
    if ($this.text().match(new RegExp(/c[0-9]/)) !== null) {
      $this.addClass('none');
    }
  });
  // Trigger the modal with the count of 'active' items
  $('#myModal').dialog({ autoOpen: true, modal: true, title: 'Active Count',
      open: function() { $(this).html('Number of active items: ' + activeCount); } });
});

document.addEventListener('DOMContentLoaded', function() {
  var cells = document.querySelectorAll('td');
  var activeCount = 0;
  cells.forEach(function(cell) {
    if (/[0-9][A-Z]/.test(cell.textContent)) {
      cell.classList.add('active');
      activeCount++;
    } else if (/c[0-9]/.test(cell.textContent)) {
      cell.classList.add('none');
    }
  });
  // Open the modal to display the count
  var modal = document.getElementById('myModal');
  modal.style.display = 'block';
  modal.innerHTML = 'Number of active items: ' + activeCount;
});

const express = require('express');
const app = express();
app.set('view engine', 'ejs');
app.get('/', (req, res) => {
  const tableData = [['1A', '2B', '3C'], ['c1', '4D', '5E']];
  let activeCount = 0;
  tableData.forEach(row => {
    row.forEach(cell => {
      if (/[0-9][A-Z]/.test(cell)) {
        activeCount++;
      }
    });
  });
  res.render('index', { activeCount });
});
app.listen(3000, () => console.log('Server running on port 3000'));

const { countActiveCells } = require('./countActive');
test('counts active cells correctly', () => {
  const tableData = [['1A', '2B', '3C'], ['c1', '4D', '5E']];
  expect(countActiveCells(tableData)).toBe(4);
});
test('returns zero if no active cells', () => {
  const tableData = [['c1', 'c2', 'c3'], ['c4', 'c5', 'c6']];
  expect(countActiveCells(tableData)).toBe(0);
});

Développement de la sélection de cellules et de la gestion des classes en JavaScript

Travailler avec et implique également la possibilité de modifier dynamiquement les classes en réponse aux entrées ou au contenu de l'utilisateur. Vous pouvez faire plus que simplement compter les cellules ; vous pouvez également gérer les entrées de l'utilisateur et modifier instantanément le contenu du tableau. Par exemple, en utilisant des méthodes comme dans jQuery ou classList.remove() dans Vanilla JavaScript, vous pouvez modifier dynamiquement la classe, mettre en surbrillance ou même supprimer la classe lorsqu'un utilisateur clique sur une cellule du tableau. Les tableaux deviennent ainsi considérablement plus interactifs et une personnalisation plus poussée basée sur des mises à jour du contenu en temps réel est possible.

Un tableau affichant des données en temps réel dans lesquelles des cellules spécifiques doivent être visuellement séparées en fonction d'un changement de classe serait un cas d'utilisation utile pour cela. Il est simple de lier les fonctions qui provoquent ces modifications à l'aide d'écouteurs d'événements. En JavaScript, par exemple, vous pouvez utiliser pour écouter les événements sur des cellules particulières, tels que les clics ou les pressions sur des touches. Modifications de classe supplémentaires ou même mises à jour d'un compteur reflétant le nombre de les cellules du tableau peuvent résulter de cette interaction.

Vous pouvez également penser à des situations dans lesquelles les cellules doivent se mettre à jour automatiquement sans aucune intervention de l'utilisateur. Le contenu du tableau peut être mis à jour et surveillé en permanence via un intervalle ou des appels AJAX. Expressions régulières et méthodes telles que permettre à la table de changer automatiquement ses classes et de lancer un modal lorsqu'un seuil est atteint. Les tableaux peuvent désormais être utilisés dans des applications plus dynamiques, telles que des tableaux de bord et des paramètres basés sur les données.

1. En JavaScript Vanilla, comment puis-je compter les composants appartenant à une classe particulière ?
2. Pour sélectionner chaque élément de cette classe, utilisez ; pour les compter, utilisez .
3. En fonction du contenu de la cellule du tableau, comment puis-je y ajouter une classe ?
4. Vous pouvez appliquer une classe en utilisant et inspecter le contenu d'une cellule à l'aide de ou propriétés.
5. Ce qui distingue en JavaScript vanille à partir de dans jQuery ?
6. est une propriété JavaScript native, et est une méthode jQuery qui récupère ou modifie le contenu des éléments sélectionnés.
7. Lors du comptage des cellules appartenant à une classe particulière, comment puis-je démarrer un modal ?
8. Pour construire un modal dans jQuery et le déclencher en fonction du nombre d'éléments avec une classe particulière, utilisez .
9. En JavaScript, comment puis-je retirer une classe d’un élément ?
10. En JavaScript Vanilla, vous pouvez utiliser pour supprimer une classe d'un élément.

JavaScript ou jQuery peuvent être utilisés pour gérer le comptage de cellules avec une classe spécifiée, telle que , de manière efficace. Les expressions régulières sont un outil utile pour identifier des modèles dans le contenu des tableaux, ce qui facilite les affectations de classes dynamiques et d'autres interactions.

De plus, une méthode utile pour informer les utilisateurs de l'état d'une table consiste à lancer un modal basé sur le nombre de ces cellules actives. Le une fonction dans jQuery ou un modal personnalisé sont deux méthodes qui offrent une grande polyvalence lorsqu'il s'agit de gérer le contenu des tables.