Extrahieren von Entitätszeichenfolgen aus einem Outlook-Element

  • Artikel

In diesem Artikel wird die Erstellung des Outlook-Add-Ins Display entities beschrieben, das Zeichenfolgeninstanzen von unterstützten bekannten Entitäten im Betreff und Textkörper des ausgewählten Outlook-Elements extrahiert. Dieses Element kann ein Termin, eine E-Mail oder eine Besprechungsanfrage, -antwort oder -stornierung sein.

Wichtig

Entitätsbasierte kontextbezogene Outlook-Add-Ins werden im 2. Quartal 2024 eingestellt. Die Arbeiten zur Einstellung dieses Features beginnen im Mai und werden bis Ende Juni fortgesetzt. Nach Juni können Kontext-Add-Ins keine Entitäten mehr in E-Mail-Elementen erkennen, um Aufgaben für sie auszuführen. Die folgenden APIs werden ebenfalls eingestellt.

Um potenzielle Unterbrechungen zu minimieren, werden die folgenden Elemente weiterhin unterstützt, nachdem entitätsbasierte Kontext-Add-Ins eingestellt wurden.

  • Eine alternative Implementierung der Schaltfläche " An Besprechung teilnehmen ", die von Onlinebesprechungs-Add-Ins aktiviert wird, wird entwickelt. Sobald die Unterstützung für entitätsbasierte Kontext-Add-Ins endet, werden Onlinebesprechungs-Add-Ins automatisch zur alternativen Implementierung übergehen, um die Schaltfläche An Besprechung teilnehmen zu aktivieren.
  • Regeln für reguläre Ausdrücke werden weiterhin unterstützt, nachdem entitätsbasierte Kontext-Add-Ins eingestellt wurden. Es wird empfohlen, Ihr Kontext-Add-In zu aktualisieren, um Regeln für reguläre Ausdrücke als alternative Lösung zu verwenden. Anleitungen zum Implementieren dieser Regeln finden Sie unter Verwenden von Aktivierungsregeln für reguläre Ausdrücke zum Anzeigen eines Outlook-Add-Ins.

Weitere Informationen finden Sie unter Außerbetriebnahme entitätsbasierter kontextbezogener Outlook-Add-Ins.

Die folgenden Entitäten werden unterstützt:

  • Adresse: Eine Postadresse in den USA, die mindestens aus Teilen von Hausnummer, Straßenname, Stadt, Staat und Postleitzahl besteht.

  • Kontakt: Die Kontaktdaten einer Person im Kontext anderer Entitäten wie einer Adresse oder einem Unternehmensnamen.

  • E-Mail-Adresse: Eine SMTP-E-Mail-Adresse.

  • Besprechungsvorschlag: Ein Besprechungsvorschlag, z. B. ein Verweis auf ein Ereignis. Beachten Sie, dass das Extrahieren von Besprechungsvorschlägen nur von Nachrichten, jedoch nicht von Terminen unterstützt wird.

  • Telefonnummer: Eine nordamerikanische Telefonnummer.

  • Vorgangsvorschlag: Ein Vorgangsvorschlag, in der Regel ausgedrückt durch einen Ausdruck, für den eine Aktion ausgeführt werden kann.

  • URL

Die meisten dieser Entitäten basieren auf der Erkennung natürlicher Sprache, die auf dem maschinellen Lernen großer Datenmengen basiert. Diese Erkennung ist nicht deterministisch und hängt manchmal vom Kontext im Outlook-Element ab.

Immer, wenn der Benutzer einen Termin, eine E-Mail-Nachricht, eine Besprechungsanfrage, eine Antwort auf eine Besprechungsanfrage oder eine Besprechungsabsage zum Anzeigen markiert, aktiviert Outlook das Entitäten-Add-In. Bei der Initialisierung liest das Entitäten-Beispiel-Add-In alle Instanzen der unterstützten Entitäten aus dem aktuellen Element.

Das Add-In stellt Schaltflächen bereit, mit denen der Benutzer einen Entitätstyp auswählen kann. Wenn der Benutzer eine Entität auswählt, zeigt das Add-In Instanzen der ausgewählten Entität im Add-in-Bereich an. In den folgenden Abschnitten werden die XML-Manifestdatei sowie HTML- und JavaScript-Dateien des Entitäten-Add-ins aufgeführt, und es wird der Code hervorgehoben, der die Extraktion der entsprechenden Entität unterstützt.

XML-Manifestdatei

Hinweis

Das in diesem Artikel beschriebene Outlook-Add-In-Feature verwendet Aktivierungsregeln, die in Add-Ins, die das einheitliche Manifest für Microsoft 365 verwenden, nicht unterstützt werden.

Das Entitäten-Add-In verfügt über die zwei Aktivierungsregeln, die durch einen logischen ODER-Operator verbunden werden:

<!-- Activate the add-in if the current item in Outlook is an email or appointment item. -->
<Rule xsi:type="RuleCollection" Mode="Or">
    <Rule xsi:type="ItemIs" ItemType="Message"/>
    <Rule xsi:type="ItemIs" ItemType="Appointment"/>
</Rule>

Diese Regeln legen fest, dass Outlook dieses Add-in aktivieren soll, wenn das aktuell ausgewählte Element im Lesebereich oder Inspektor ein Termin oder eine Nachricht ist (einschließlich E-Mail, Besprechungsanfrage, -antwort oder -stornierung).

Im Folgenden ist das Manifest des Entitäten-Add-Ins angezeigt. Es verwendet Version 1.1 des Schemas für Office-Add-Ins-Manifeste.

<?xml version="1.0" encoding="utf-8"?>
<OfficeApp xmlns="http://schemas.microsoft.com/office/appforoffice/1.1" 
xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" 
xsi:type="MailApp">
  <Id>6880A140-1C4F-11E1-BDDB-0800200C9A68</Id>
  <Version>1.0</Version>
  <ProviderName>Microsoft</ProviderName>
  <DefaultLocale>EN-US</DefaultLocale>
  <DisplayName DefaultValue="Display entities"/>
  <Description DefaultValue=
     "Display known entities on the selected item."/>
  <Hosts>
    <Host Name="Mailbox" />
  </Hosts>
  <Requirements>
    <Sets DefaultMinVersion="1.1">
      <Set Name="Mailbox" />
    </Sets>
  </Requirements>
  <FormSettings>
    <Form xsi:type="ItemRead">
      <DesktopSettings>
        <!-- Change the following line to specify the web -->
        <!-- server where the HTML file is hosted. -->
        <SourceLocation DefaultValue=
          "http://webserver/default_entities/default_entities.html"/>
        <RequestedHeight>350</RequestedHeight>
      </DesktopSettings>
    </Form>
  </FormSettings>
  <Permissions>ReadItem</Permissions>
  <!-- Activate the add-in if the current item in Outlook is -->
  <!-- an email or appointment item. -->
  <Rule xsi:type="RuleCollection" Mode="Or">
    <Rule xsi:type="ItemIs" ItemType="Message"/>
    <Rule xsi:type="ItemIs" ItemType="Appointment"/>
  </Rule>
  <DisableEntityHighlighting>false</DisableEntityHighlighting>
</OfficeApp>

HTML-Implementierung

Die HTML-Datei des Entitäten-Add-Ins legt Schaltflächen fest, mit denen der Benutzer die einzelnen Entitätentypen auswählen kann, sowie eine weitere Schaltfläche, um die angezeigten Instanzen jeder Entität zu löschen. Es ist zudem eine JavaScript-Datei, default_entities.js, vorhanden, die im folgenden Abschnitt unter JavaScript-Implementierung beschrieben wird. Die JavaScript-Datei enthält die Ereignishandler für alle Schaltflächen.

Beachten Sie, dass alle Outlook-Add-Ins die Datei „office.js" enthalten müssen. Die folgende HTML-Datei enthält Version 1.1 von office.js im Content Delivery Network (CDN).

<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="X-UA-Compatible" content="IE=Edge" >
    <title>standard_item_properties</title>
    <link rel="stylesheet" type="text/css" media="all" href="default_entities.css" />
    <script type="text/javascript" src="MicrosoftAjax.js"></script>
    <!-- Use the CDN reference to Office.js. -->
    <script src="https://appsforoffice.microsoft.com/lib/1/hosted/Office.js" type="text/javascript"></script>
    <script type="text/javascript"  src="default_entities.js"></script>
</head>

<body>
    <div id="container">
        <div id="button">
        <input type="button" value="clear" 
            onclick="myClearEntitiesBox();">
        <input type="button" value="Get Addresses" 
            onclick="myGetAddresses();">
        <input type="button" value="Get Contact Information" 
            onclick="myGetContacts();">
        <input type="button" value="Get Email Addresses" 
            onclick="myGetEmailAddresses();">
        <input type="button" value="Get Meeting Suggestions" 
            onclick="myGetMeetingSuggestions();">
        <input type="button" value="Get Phone Numbers" 
            onclick="myGetPhoneNumbers();">
        <input type="button" value="Get Task Suggestions" 
            onclick="myGetTaskSuggestions();">
        <input type="button" value="Get URLs" 
            onclick="myGetUrls();">
        </div>
        <div id="entities_box"></div>
    </div>
</body>
</html>

Stylesheet

Das Entitäten-Add-In kann optional eine CSS-Datei, default_entities.css, verwenden, um das Layout der Ausgabe festzulegen. Die CSS-Datei wird im Anschluss aufgeführt.

{
    color: #FFFFFF;
    margin: 0px;
    padding: 0px;
    font-family: Arial, Sans-serif;
}
html 
{
    scrollbar-base-color: #FFFFFF;
    scrollbar-arrow-color: #ABABAB; 
    scrollbar-lightshadow-color: #ABABAB; 
    scrollbar-highlight-color: #ABABAB; 
    scrollbar-darkshadow-color: #FFFFFF; 
    scrollbar-track-color: #FFFFFF;
}
body
{
    background: #4E9258;
}
input
{
    color: #000000;
    padding: 5px;
}
span
{
    color: #FFFF00;
}
div#container
{
    height: 100%;
    padding: 2px;
    overflow: auto;
}
div#container td
{
    border-bottom: 1px solid #CCCCCC;
}
td.property-name
{
    padding: 0px 5px 0px 0px;
    border-right: 1px solid #CCCCCC;
}
div#meeting_suggestions
{
    border-top: 1px solid #CCCCCC;
}

JavaScript-Implementierung

In den restlichen Abschnitten wird erläutert, wie dieses Beispiel (default_entities.js-Datei) bekannte Entitäten aus dem Betreff und Text der Nachricht oder des Termins extrahiert, das der Benutzer anzeigt.

Extrahieren von Entitäten bei der Initialisierung

Beim Auftreten des Office.initiatlize-Ereignisses ruft das Entitäten-Add-In die getEntities-Methode des aktuellen Elements auf. Die getEntities -Methode gibt die globale Variable _MyEntities ein Array von Instanzen unterstützter Entitäten zurück. Das Folgende ist der entsprechende JavaScript-Code.

// Global variables
let _Item;
let _MyEntities;

// The initialize function is required for all add-ins.
Office.initialize = function () {
    const _mailbox = Office.context.mailbox;
    // Obtains the current item.
    _Item = _mailbox.item;
    // Reads all instances of supported entities from the subject 
    // and body of the current item.
    _MyEntities = _Item.getEntities();
    
    // Checks for the DOM to load using the jQuery ready method.
    $(document).ready(function () {
    // After the DOM is loaded, app-specific code can run.
    });
}

Extrahieren von Adressen

Wenn der Benutzer auf die Schaltfläche Adressen abrufen klickt, ruft der Ereignishandler myGetAddresses von der addresses-Eigenschaft des _MyEntities-Objekts ein Array von Adressen ab, wenn solche extrahiert wurden. Jede extrahierte Adresse wird als eine Zeichenfolge im Array gespeichert. myGetAddresses bildet eine lokale HTML-Zeichenfolge in htmlText, um die Liste der extrahierten Adressen anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the Address entity on the item.
function myGetAddresses()
{
    let htmlText = "";

    // Gets an array of postal addresses. Each address is a string.
    const addressesArray = _MyEntities.addresses;
    for (let i = 0; i < addressesArray.length; i++)
    {
        htmlText += "Address : <span>" + addressesArray[i] + "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von Kontaktinformationen

Wenn der Benutzer auf die Schaltfläche Kontaktinformationen abrufen klickt, ruft der myGetContacts Ereignishandler ein Array von Kontakten zusammen mit ihren Informationen aus der contacts-Eigenschaft des _MyEntities Objekts ab, sofern diese extrahiert wurden. Jeder extrahierte Kontakt wird als Contact-Objekt im Array gespeichert. myGetContacts erhält weitere Daten zu jedem Kontakt. Beachten Sie, dass der Kontext bestimmt, ob Outlook einen Kontakt aus einem Element extrahieren kann – eine Signatur am Ende einer E-Mail-Nachricht oder zumindest einige der folgenden Informationen müssten in der Nähe des Kontakts vorhanden sein.

  • Die Zeichenfolge, die den Namen des Kontakts von der Contact.personName-Eigenschaft darstellt

  • Die Zeichenfolge, die den mit dem Kontakt von der Contact.businessName-Eigenschaft verbundenen Unternehmensnamen darstellt

  • Das mit dem Kontakt von der Contact.phoneNumbers-Eigenschaft verbundene Array von Telefonnummern. Jede Telefonnummer wird durch ein PhoneNumber-Objekt dargestellt

  • Für jedes PhoneNumber-Element im Telefonnummernarray die Zeichenfolge, die die Telefonnummer von der PhoneNumber.phoneString-Eigenschaft darstellt.

  • Das Array der mit dem Kontakt von der Contact.urls-Eigenschaft verbundenen URLs. Jede URL wird als Zeichenfolge in einem Arrayelement dargestellt.

  • Das Array der mit dem Kontakt von der Contact.emailAddresses-Eigenschaft verbundenen E-Mail-Adressen. Jede E-Mail-Adresse wird als Zeichenfolge in einem Arrayelement dargestellt.

  • Das Array der mit dem Kontakt von der Contact.addresses-Eigenschaft verbundenen Postadressen. Jede Postadresse wird als Zeichenfolge in einem Arrayelement dargestellt.

myGetContacts bildet eine lokale HTML-Zeichenfolge in htmlText, um die Daten für jeden Kontakt anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the Contact entity on the item.
function myGetContacts()
{
    let htmlText = "";

    // Gets an array of contacts and their information.
    const contactsArray = _MyEntities.contacts;
    for (let i = 0; i < contactsArray.length; i++)
    {
        // Gets the name of the person. The name is a string.
        htmlText += "Name : <span>" + contactsArray[i].personName +
            "</span><br/>";

        // Gets the company name associated with the contact.
        htmlText += "Business : <span>" + 
        contactsArray[i].businessName + "</span><br/>";

        // Gets an array of phone numbers associated with the 
        // contact. Each phone number is represented by a 
        // PhoneNumber object.
        let phoneNumbersArray = contactsArray[i].phoneNumbers;
        for (let j = 0; j < phoneNumbersArray.length; j++)
        {
            htmlText += "PhoneString : <span>" + 
                phoneNumbersArray[j].phoneString + "</span><br/>";
            htmlText += "OriginalPhoneString : <span>" + 
                phoneNumbersArray[j].originalPhoneString +
                "</span><br/>";
        }

        // Gets the URLs associated with the contact.
        let urlsArray = contactsArray[i].urls;
        for (let j = 0; j < urlsArray.length; j++)
        {
            htmlText += "Url : <span>" + urlsArray[j] + 
                "</span><br/>";
        }

        // Gets the email addresses of the contact.
        let emailAddressesArray = contactsArray[i].emailAddresses;
        for (let j = 0; j < emailAddressesArray.length; j++)
        {
           htmlText += "E-mail Address : <span>" + 
               emailAddressesArray[j] + "</span><br/>";
        }

        // Gets postal addresses of the contact.
        let addressesArray = contactsArray[i].addresses;
        for (let j = 0; j < addressesArray.length; j++)
        {
          htmlText += "Address : <span>" + addressesArray[j] + 
              "</span><br/>";
        }

        htmlText += "<hr/>";
        }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von E-Mail-Adressen

Wenn der Benutzer auf die Schaltfläche Get Email Addresses (Adressen abrufen) klickt, ruft der myGetEmailAddresses Ereignishandler ein Array von SMTP-E-Mail-Adressen aus der emailAddresses-Eigenschaft des _MyEntities Objekts ab, sofern diese extrahiert wurden. Jede extrahierte E-Mail-Adresse wird als Zeichenfolge in dem Array gespeichert. myGetEmailAddresses bildet eine lokale HTML-Zeichenfolge in htmlText, um die Liste der extrahierten E-Mail-Adressen anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the EmailAddress entity on the item.
function myGetEmailAddresses() {
    let htmlText = "";

    // Gets an array of email addresses. Each email address is a 
    // string.
    const emailAddressesArray = _MyEntities.emailAddresses;
    for (let i = 0; i < emailAddressesArray.length; i++) {
        htmlText += "E-mail Address : <span>" + emailAddressesArray[i] + "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von Besprechungsvorschlägen

Wenn der Benutzer auf die Schaltfläche Besprechungsvorschläge abrufen klickt, ruft der Ereignishandler myGetMeetingSuggestions von der meetingSuggestions-Eigenschaft des _MyEntities-Objekts ein Array von Besprechungsvorschlägen ab, wenn solche extrahiert wurden.

Hinweis

Nur Nachrichten, aber keine Termine unterstützen den MeetingSuggestion Entitätstyp.

Jeder extrahierte Besprechungsvorschlag wird im Array in einem MeetingSuggestion-Objekt gespeichert. myGetMeetingSuggestions ruft weitere Daten zu jedem Besprechungsvorschlag ab:

myGetMeetingSuggestions bildet eine lokale HTML-Zeichenfolge in htmlText, um die Daten für jeden Besprechungsvorschlag anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the MeetingSuggestion entity on the 
// message item.
function myGetMeetingSuggestions() {
    let htmlText = "";

    // Gets an array of MeetingSuggestion objects, each array 
    // element containing an instance of a meeting suggestion 
    // entity from the current item.
    const meetingsArray = _MyEntities.meetingSuggestions;

    // Iterates through each instance of a meeting suggestion.
    for (let i = 0; i < meetingsArray.length; i++) {
        // Gets the string that was identified as a meeting suggestion.
        htmlText += "MeetingString : <span>" + meetingsArray[i].meetingString + "</span><br/>";

        // Gets an array of attendees for that instance of a 
        // meeting suggestion. Each attendee is represented 
        // by an EmailUser object.
        let attendeesArray = meetingsArray[i].attendees;
        for (let j = 0; j < attendeesArray.length; j++) {
            htmlText += "Attendee : ( ";

            // Gets the displayName property of the attendee.
            htmlText += "displayName = <span>" + attendeesArray[j].displayName + "</span> , ";

            // Gets the emailAddress property of each attendee.
            // This is the SMTP address of the attendee.
            htmlText += "emailAddress = <span>" + attendeesArray[j].emailAddress + "</span>";

            htmlText += " )<br/>";
        }

        // Gets the location of the meeting suggestion.
        htmlText += "Location : <span>" + meetingsArray[i].location + "</span><br/>";

        // Gets the subject of the meeting suggestion.
        htmlText += "Subject : <span>" + meetingsArray[i].subject + "</span><br/>";

        // Gets the start time of the meeting suggestion.
        htmlText += "Start time : <span>" + meetingsArray[i].start + "</span><br/>";

        // Gets the end time of the meeting suggestion.
        htmlText += "End time : <span>" + meetingsArray[i].end + "</span><br/>";

        htmlText += "<hr/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von Telefonnummern

Wenn der Benutzer auf die Schaltfläche Telefonnummern abrufen klickt, ruft der myGetPhoneNumbers Ereignishandler ein Array von Telefonnummern aus der phoneNumbers-Eigenschaft des _MyEntities Objekts ab, sofern diese extrahiert wurden. Jede extrahierte Telefonnummer wird im Array in einem PhoneNumber-Objekt gespeichert. myGetPhoneNumbers ruft weitere Daten zu jeder Telefonnummer ab:

  • Die Zeichenfolge, die die Art der Telefonnummer darstellt, beispielsweise die Privattelefonnummer von der PhoneNumber.type-Eigenschaft

  • Die Zeichenfolge, die die tatsächliche Telefonnummer von der PhoneNumber.phoneString-Eigenschaft darstellt

  • Die Zeichenfolge, die ursprünglich als Telefonnummer von der PhoneNumber.originalPhoneString-Eigenschaft erkannt wurde

myGetPhoneNumbers bildet eine lokale HTML-Zeichenfolge in htmlText, um die Daten für jede Telefonnummer anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the phone number entity on the item.
function myGetPhoneNumbers()
{
    let htmlText = "";

    // Gets an array of phone numbers. 
    // Each phone number is a PhoneNumber object.
    const phoneNumbersArray = _MyEntities.phoneNumbers;
    for (let i = 0; i < phoneNumbersArray.length; i++)
    {
        htmlText += "Phone Number : ( ";
        // Gets the type of phone number, for example, home, office.
        htmlText += "type = <span>" + phoneNumbersArray[i].type + 
           "</span> , ";

        // Gets the actual phone number represented by a string.
        htmlText += "phone string = <span>" + 
            phoneNumbersArray[i].phoneString + "</span> , ";

        // Gets the original text that was identified in the item 
        // as a phone number. 
        htmlText += "original phone string = <span>" + 
            phoneNumbersArray[i].originalPhoneString + "</span>";

        htmlText += " )<br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von Vorgangsvorschlägen

Wenn der Benutzer auf die Schaltfläche Aufgabenvorschläge abrufen klickt, ruft der myGetTaskSuggestions Ereignishandler ein Array von Aufgabenvorschlägen aus der taskSuggestions-Eigenschaft des _MyEntities Objekts ab, sofern diese extrahiert wurden. Jeder extrahierte Vorgangsvorschlag wird im Array in einem TaskSuggestion-Objekt gespeichert. myGetTaskSuggestions ruft weitere Daten zu jedem Vorgangsvorschlag ab:

myGetTaskSuggestions bildet eine lokale HTML-Zeichenfolge in htmlText, um die Daten für jeden Vorgangsvorschlag anzuzeigen. Das Folgende ist der entsprechende JavaScript-Code.

// Gets instances of the task suggestion entity on the item.
function myGetTaskSuggestions()
{
    let htmlText = "";

    // Gets an array of TaskSuggestion objects, each array element 
    // containing an instance of a task suggestion entity from 
    // the current item.
    const tasksArray = _MyEntities.taskSuggestions;

    // Iterates through each instance of a task suggestion.
    for (let i = 0; i < tasksArray.length; i++)
    {
        // Gets the string that was identified as a task suggestion.
        htmlText += "TaskString : <span>" + 
           tasksArray[i].taskString + "</span><br/>";

        // Gets an array of assignees for that instance of a task 
        // suggestion. Each assignee is represented by an 
        // EmailUser object.
        let assigneesArray = tasksArray[i].assignees;
        for (let j = 0; j < assigneesArray.length; j++)
        {
            htmlText += "Assignee : ( ";
            // Gets the displayName property of the assignee.
            htmlText += "displayName = <span>" + assigneesArray[j].displayName + 
               "</span> , ";

            // Gets the emailAddress property of each assignee.
            // This is the SMTP address of the assignee.
            htmlText += "emailAddress = <span>" + assigneesArray[j].emailAddress + 
                "</span>";

            htmlText += " )<br/>";
        }

        htmlText += "<hr/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Extrahieren von URLs

Wenn der Benutzer auf die Schaltfläche URLs abrufen klickt, ruft der myGetUrls Ereignishandler ein Array von URLs aus der urls-Eigenschaft des _MyEntities Objekts ab, sofern diese extrahiert wurden. Jede extrahierte URL wird als Zeichenfolge in dem Array gespeichert. myGetUrls bildet eine lokale HTML-Zeichenfolge in htmlText, um die Liste der extrahierten URLs anzuzeigen.

// Gets instances of the URL entity on the item.
function myGetUrls()
{
    let htmlText = "";

    // Gets an array of URLs. Each URL is a string.
    const urlArray = _MyEntities.urls;
    for (let i = 0; i < urlArray.length; i++)
    {
        htmlText += "Url : <span>" + urlArray[i] + "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Löschen von angezeigten Entitätszeichenfolgen

Schließlich gibt das Entitäts-Add-In einen myClearEntitiesBox Ereignishandler an, der alle angezeigten Zeichenfolgen löscht. Das Folgende ist der entsprechende Code.

// Clears the div with id="entities_box".
function myClearEntitiesBox()
{
    document.getElementById("entities_box").innerHTML = "";
}

JavaScript-Auflistung

Das Folgende ist die vollständige Auflistung der JavaScript-Implementierung.

// Global variables
let _Item;
let _MyEntities;

// Initializes the add-in.
Office.initialize = function () {
    const _mailbox = Office.context.mailbox;
    // Obtains the current item.
    _Item = _mailbox.item;
    // Reads all instances of supported entities from the subject 
    // and body of the current item.
    _MyEntities = _Item.getEntities();

    // Checks for the DOM to load using the jQuery ready method.
    $(document).ready(function () {
    // After the DOM is loaded, app-specific code can run.
    });
}

// Clears the div with id="entities_box".
function myClearEntitiesBox()
{
    document.getElementById("entities_box").innerHTML = "";
}

// Gets instances of the Address entity on the item.
function myGetAddresses()
{
    let htmlText = "";

    // Gets an array of postal addresses. Each address is a string.
    const addressesArray = _MyEntities.addresses;
    for (let i = 0; i < addressesArray.length; i++)
    {
        htmlText += "Address : <span>" + addressesArray[i] + 
            "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

// Gets instances of the EmailAddress entity on the item.
function myGetEmailAddresses()
{
    let htmlText = "";

    // Gets an array of email addresses. Each email address is a 
    // string.
    const emailAddressesArray = _MyEntities.emailAddresses;
    for (let i = 0; i < emailAddressesArray.length; i++)
    {
        htmlText += "E-mail Address : <span>" + 
            emailAddressesArray[i] + "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

// Gets instances of the MeetingSuggestion entity on the 
// message item.
function myGetMeetingSuggestions()
{
    let htmlText = "";

    // Gets an array of MeetingSuggestion objects, each array 
    // element containing an instance of a meeting suggestion 
    // entity from the current item.
    const meetingsArray = _MyEntities.meetingSuggestions;

    // Iterates through each instance of a meeting suggestion.
    for (let i = 0; i < meetingsArray.length; i++)
    {
        // Gets the string that was identified as a meeting 
        // suggestion.
        htmlText += "MeetingString : <span>" + 
            meetingsArray[i].meetingString + "</span><br/>";

        // Gets an array of attendees for that instance of a 
        // meeting suggestion.
        // Each attendee is represented by an EmailUser object.
        let attendeesArray = meetingsArray[i].attendees;
        for (let j = 0; j < attendeesArray.length; j++)
        {
            htmlText += "Attendee : ( ";
            // Gets the displayName property of the attendee.
            htmlText += "displayName = <span>" + attendeesArray[j].displayName + 
                "</span> , ";

            // Gets the emailAddress property of each attendee.
            // This is the SMTP address of the attendee.
            htmlText += "emailAddress = <span>" + attendeesArray[j].emailAddress + 
                "</span>";

            htmlText += " )<br/>";
        }

        // Gets the location of the meeting suggestion.
        htmlText += "Location : <span>" + 
            meetingsArray[i].location + "</span><br/>";

        // Gets the subject of the meeting suggestion.
        htmlText += "Subject : <span>" + 
            meetingsArray[i].subject + "</span><br/>";

        // Gets the start time of the meeting suggestion.
        htmlText += "Start time : <span>" + 
           meetingsArray[i].start + "</span><br/>";

        // Gets the end time of the meeting suggestion.
        htmlText += "End time : <span>" + 
            meetingsArray[i].end + "</span><br/>";

        htmlText += "<hr/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

// Gets instances of the phone number entity on the item.
function myGetPhoneNumbers()
{
    let htmlText = "";

    // Gets an array of phone numbers. 
    // Each phone number is a PhoneNumber object.
    const phoneNumbersArray = _MyEntities.phoneNumbers;
    for (let i = 0; i < phoneNumbersArray.length; i++)
    {
        htmlText += "Phone Number : ( ";
        // Gets the type of phone number, for example, home, office.
        htmlText += "type = <span>" + phoneNumbersArray[i].type + 
            "</span> , ";

        // Gets the actual phone number represented by a string.
        htmlText += "phone string = <span>" + 
            phoneNumbersArray[i].phoneString + "</span> , ";

        // Gets the original text that was identified in the item 
        // as a phone number. 
        htmlText += "original phone string = <span>" + 
           phoneNumbersArray[i].originalPhoneString + "</span>";

        htmlText += " )<br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

// Gets instances of the task suggestion entity on the item.
function myGetTaskSuggestions()
{
    let htmlText = "";

    // Gets an array of TaskSuggestion objects, each array element 
    // containing an instance of a task suggestion entity from the 
    // current item.
    const tasksArray = _MyEntities.taskSuggestions;

    // Iterates through each instance of a task suggestion.
    for (let i = 0; i < tasksArray.length; i++)
    {
        // Gets the string that was identified as a task suggestion.
        htmlText += "TaskString : <span>" + 
            tasksArray[i].taskString + "</span><br/>";

        // Gets an array of assignees for that instance of a task 
        // suggestion. Each assignee is represented by an 
        // EmailUser object.
        let assigneesArray = tasksArray[i].assignees;
        for (let j = 0; j < assigneesArray.length; j++)
        {
            htmlText += "Assignee : ( ";
            // Gets the displayName property of the assignee.
            htmlText += "displayName = <span>" + assigneesArray[j].displayName + 
                "</span> , ";

            // Gets the emailAddress property of each assignee.
            // This is the SMTP address of the assignee.
            htmlText += "emailAddress = <span>" + assigneesArray[j].emailAddress + 
                "</span>";

            htmlText += " )<br/>";
        }

        htmlText += "<hr/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

// Gets instances of the URL entity on the item.
function myGetUrls()
{
    let htmlText = "";

    // Gets an array of URLs. Each URL is a string.
    const urlArray = _MyEntities.urls;
    for (let i = 0; i < urlArray.length; i++)
    {
        htmlText += "Url : <span>" + urlArray[i] + "</span><br/>";
    }

    document.getElementById("entities_box").innerHTML = htmlText;
}

Siehe auch