Comment ajouter une mise en forme conditionnelle de texte

Scénarios d’utilisation possibles

L’utilisation de la mise en forme conditionnelle basée sur du texte dans les feuilles de calcul est utile pour mettre en évidence les cellules répondant à des critères textuels spécifiques. Cela peut améliorer l’analyse des données et faciliter la recherche d’informations clés dans un grand ensemble de données. Voici quelques raisons d’utiliser la mise en forme conditionnelle de texte :

1. Mettre en évidence un texte spécifique : Vous pouvez appliquer une mise en forme en fonction de mots, phrases ou caractères spécifiques. Par exemple, vous pourriez vouloir mettre en surbrillance toutes les cellules contenant le mot “Urgent” ou “Terminé” pour différencier facilement les tâches d’un projet.
2. Identifier les motifs ou tendances : Si vous travaillez avec des catégories ou statuts (comme “Élevé”, “Moyen”, “Faible”), la mise en forme conditionnelle de texte peut visuellement distinguer entre eux, facilitant le suivi de l’avancement ou la priorisation des tâches.
3. Alertes d’erreur ou de saisie de données : La mise en forme du texte peut signaler des entrées incohérentes ou erronées, comme des mots mal orthographiés, du texte incomplet ou des valeurs incorrectes. Cela est particulièrement utile dans des ensembles de données avec beaucoup de texte.
4. Amélioration de la lisibilité : La codification par couleur du texte ou la modification de son style (gras, italique, etc.) aide à faire ressortir les informations importantes, améliorant la lisibilité globale de votre feuille.
5. Retour d’information dynamique : Vous pouvez mettre en place des règles qui ajustent automatiquement la mise en forme lorsque le texte correspond à certaines conditions. Cela évite de devoir mettre à jour manuellement la mise en forme à mesure que les données changent.

En résumé, la mise en forme conditionnelle de texte vous aide à repérer rapidement les informations pertinentes, les erreurs et les tendances, ce qui en fait un outil puissant pour gérer et interpréter des données textuelles.

Comment ajouter une mise en forme conditionnelle de texte avec Excel

Pour ajouter une mise en forme conditionnelle basée sur du texte dans Excel, suivez ces étapes :

1. Sélectionnez la plage de cellules : Mettez en surbrillance les cellules où vous souhaitez appliquer la mise en forme conditionnelle.
2. Ouvrez le menu Mise en forme conditionnelle : Allez à l’onglet Accueil dans le ruban Excel. Cliquez sur Mise en forme conditionnelle dans le groupe “Styles”.
3. Choisissez “Nouvelle règle” : Dans le menu déroulant, sélectionnez Nouvelle règle.
4. Sélectionnez “Mettre en forme uniquement les cellules qui contiennent” : Dans la boîte de dialogue Nouvelle règle de mise en forme, choisissez Mettre en forme uniquement les cellules qui contiennent sous la section “Type de règle”.
5. Définissez les critères de la règle : Dans la section “Mettre en forme les cellules avec”, choisissez Texte spécifique dans le menu déroulant. Sélectionnez soit contenant, commence par ou se terminant par, selon la condition que vous souhaitez appliquer. Entrez le texte que vous souhaitez mettre en forme (par exemple un mot spécifique comme “Urgent” ou “Terminé”).
6. Choisissez la mise en forme : Cliquez sur le bouton Mettre en forme. Dans la boîte de dialogue Format de cellules, vous pouvez sélectionner la couleur de police, la couleur de remplissage ou d’autres options de mise en forme selon vos préférences.
7. Appliquez la règle : Une fois que vous avez défini votre mise en forme souhaitée, cliquez sur OK pour appliquer la règle. Cliquez de nouveau sur OK dans la boîte de dialogue Nouvelle règle de mise en forme pour la fermer.
8. Visualisez les résultats : Les cellules contenant le texte spécifié auront désormais la mise en forme appliquée, ce qui facilite la détection des informations pertinentes.

Comment ajouter une mise en forme conditionnelle de texte avec Aspose.Cells for .NET

Aspose.Cells supporte pleinement la mise en forme conditionnelle fournie par Microsoft Excel 2007 et versions ultérieures en format XLSX sur des cellules à l’exécution. Ces exemples illustrent des exercices pour des types avancés de mise en forme conditionnelle, y compris BeginsWith, ContainsBlank, ContainsText, etc.

Mettre en forme la cellule lorsque la valeur commence par un texte spécifié

// This method implements the BeginsWith conditional formatting type.
private void AddBeginWith()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];
    FormatConditionCollection conds = GetFormatCondition("E15:G16", Color.LightGoldenrodYellow, _sheet);
    int idx = conds.AddCondition(FormatConditionType.BeginsWith);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Pink;
    cond.Style.Pattern = BackgroundType.Solid;
    cond.Text = "ab";
    Cell c = _sheet.Cells["E15"];
    c.PutValue("abc");
    c = _sheet.Cells["G16"];
    c.PutValue("babx");
    book.Save("BeginsWith.xlsx");
}

// This method adds formatted conditions.
private FormatConditionCollection GetFormatCondition(string cellAreaName, Color color, Worksheet _sheet)
{
    // Adds an empty conditional formattings
    int index = _sheet.ConditionalFormattings.Add();
    // Get the formatted conditions
    FormatConditionCollection formatConditions = _sheet.ConditionalFormattings[index];
    // Get the cell area calling the custom GetCellAreaByName method
    CellArea area = GetCellAreaByName(cellAreaName);
    // Add the formatted conditions cell area.
    formatConditions.AddArea(area);
    // Call the custom FillCell method
    FillCell(cellAreaName, color, _sheet);
    // Return the formatted conditions
    return formatConditions;
}

// This method specifies the cell shading color for the conditional formattings cellarea range.
private void FillCell(string cellAreaName, Color color, Worksheet _sheet)
{
    CellArea area = GetCellAreaByName(cellAreaName);
    int k = 0;
    for (int i = area.StartColumn; i <= area.EndColumn; i++)
    {
        for (int j = area.StartRow; j <= area.EndRow; j++)
        {
            Cell c = _sheet.Cells[j, i];
            if (!color.IsEmpty)
            {
                Style s = c.GetStyle();
                s.ForegroundColor = color;
                s.Pattern = BackgroundType.Solid;
                c.SetStyle(s);
            }
            // Set some random values to the cells in the cellarea range
            int value = j + i + k;
            c.PutValue(value);
            k++;
        }
    }

}
// This method specifies the CellArea range (start row, start col, end row, end col etc.)
// For the conditional formatting
internal static CellArea GetCellAreaByName(string s)
{
    CellArea area = new CellArea();
    string[] strCellRange = s.Replace("$", "").Split(':');
    int column;
    CellsHelper.CellNameToIndex(strCellRange[0], out area.StartRow, out column);
    area.StartColumn = column;
    if (strCellRange.Length == 1)
    {
        area.EndRow = area.StartRow;
        area.EndColumn = area.StartColumn;
    }
    else
    {
        CellsHelper.CellNameToIndex(strCellRange[1], out area.EndRow, out column);
        area.EndColumn = column;
    }
    return area;
}

Formatage de cellule lorsque la valeur contient une case vide

// This method implements the ContainsBlank conditional formatting type.
private void AddContainsBlank()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E9:G10", Color.LightBlue, _sheet);
    int idx = conds.AddCondition(FormatConditionType.ContainsBlanks);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Yellow;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E9"];
    c.PutValue("  ");
    c = _sheet.Cells["G10"];
    c.PutValue("  ");
    book.Save("ContainsBlank.xlsx");
}

Formatage de cellule lorsque la valeur contient des erreurs

// This method implements the ContainsErrors conditional formatting type.
private void AddContainsErrors()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];
    FormatConditionCollection conds = GetFormatCondition("E17:G18", Color.LightSkyBlue, _sheet);
    int idx = conds.AddCondition(FormatConditionType.ContainsErrors);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Yellow;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E17"];
    c.PutValue("  ");
    c = _sheet.Cells["G18"];
    c.PutValue("  ");
    book.Save("ContainsErrors.xlsx");
}

Formatage de cellule lorsque la valeur contient un texte spécifié

// This method implements the ContainsText conditional formatting type.
private void AddContainsText()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];
    FormatConditionCollection conds = GetFormatCondition("E5:G6", Color.LightBlue, _sheet);
    int idx = conds.AddCondition(FormatConditionType.ContainsText);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Yellow;
    cond.Style.Pattern = BackgroundType.Solid;
    cond.Text = "1";
    book.Save("ContainsText.xlsx");
}
        

Formatage de cellule lorsque la valeur contient des valeurs en double

// This method implements the DuplicateValues conditional formatting type.
private void AddDuplicateValues()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E23:G24", Color.LightSlateGray, _sheet);
    int idx = conds.AddCondition(FormatConditionType.DuplicateValues);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Pink;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E23"];
    c.PutValue("bb");
    c = _sheet.Cells["G24"];
    c.PutValue("bb");
    book.Save("DuplicateValues.xlsx");
}

Formatage de cellule lorsque la valeur se termine par un texte spécifié

// This method implements the EndsWith conditional formatting type.
private void AddEndWith()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E13:G14", Color.LightGray, _sheet);
    int idx = conds.AddCondition(FormatConditionType.EndsWith);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Yellow;
    cond.Style.Pattern = BackgroundType.Solid;
    cond.Text = "ab";
    Cell c = _sheet.Cells["E13"];
    c.PutValue("nnnab");
    c = _sheet.Cells["G14"];
    c.PutValue("mmmabc");
    book.Save("EndsWith.xlsx");
}

Formatage de cellule lorsque la valeur ne contient pas une case vide

// This method implements the NotContainsBlank conditional formatting type.
private void AddNotContainsBlank()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E11:G12", Color.LightCoral, _sheet);
    int idx = conds.AddCondition(FormatConditionType.NotContainsBlanks);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Pink;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E11"];
    c.PutValue("abc");
    c = _sheet.Cells["G12"];
    c.PutValue("  ");
    book.Save("NotContainsBlank.xlsx");
}

Formatage de cellule lorsque la valeur ne contient pas d’erreurs

// This method implements the NotContainsErrors conditional formatting type.
private void AddNotContainsErrors()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E19:G20", Color.LightSeaGreen, _sheet);
    int idx = conds.AddCondition(FormatConditionType.NotContainsErrors);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Pink;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E19"];
    c.PutValue("  ");
    c = _sheet.Cells["G20"];
    c.PutValue("  ");
    book.Save("NotContainsErrors.xlsx");
}

Formatage de cellule lorsque la valeur ne contient pas un texte spécifié

// This method implements the NotContainsText conditional formatting type.
private void AddNotContainsText()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];

    FormatConditionCollection conds = GetFormatCondition("E7:G8", Color.LightCoral, _sheet);
    int idx = conds.AddCondition(FormatConditionType.NotContainsText);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Pink;
    cond.Style.Pattern = BackgroundType.Solid;
    cond.Text = "3";
    book.Save("NotContainsText.xlsx");
}

Formatage de cellule lorsque la valeur contient des valeurs uniques

// This method implements the UniqueValues conditional formatting type.
private void AddUniqueValues()
{
    // Instantiate a workbook object
    Workbook book = new Workbook();
    // Create a worksheet object and get the first worksheet
    Worksheet _sheet = book.Worksheets[0];
    FormatConditionCollection conds = GetFormatCondition("E21:G22", Color.LightSalmon, _sheet);
    int idx = conds.AddCondition(FormatConditionType.UniqueValues);
    FormatCondition cond = conds[idx];
    cond.Style.BackgroundColor = Color.Yellow;
    cond.Style.Pattern = BackgroundType.Solid;
    Cell c = _sheet.Cells["E21"];
    c.PutValue("aa");
    c = _sheet.Cells["G22"];
    c.PutValue("aa");
    book.Save("UniqueValues.xlsx");
}