diff --git a/.markdownlint.json b/.markdownlint.json new file mode 100644 index 000000000..47a605070 --- /dev/null +++ b/.markdownlint.json @@ -0,0 +1,6 @@ +{ + "MD025": false, + "MD033": { + "allowed_elements": ["kbd"] + } +} diff --git a/docs/excel/custom-functions-batching.md b/docs/excel/custom-functions-batching.md index a0500a29c..44f6790bb 100644 --- a/docs/excel/custom-functions-batching.md +++ b/docs/excel/custom-functions-batching.md @@ -1,5 +1,5 @@ --- -ms.date: 09/09/2022 +ms.date: 09/19/2025 description: Batch custom functions together to reduce network calls to a remote service. title: Batching custom function calls for a remote service ms.topic: best-practice @@ -8,19 +8,11 @@ ms.localizationpriority: medium # Batch custom function calls for a remote service -If your custom functions call a remote service you can use a batching pattern to reduce the number of network calls to the remote service. To reduce network round trips you batch all the calls into a single call to the web service. This is ideal when the spreadsheet is recalculated. +Use batching to group calls to a remote service into one network request. This cuts down the number of network round trips to your remote service and helps the worksheet finish recalculating faster. -For example, if someone used your custom function in 100 cells in a spreadsheet, and then recalculated the spreadsheet, your custom function would run 100 times and make 100 network calls. By using a batching pattern, the calls can be combined to make all 100 calculations in a single network call. +Here's a batching example scenario: 100 cells call the custom function. Instead of 100 network requests, you send one request that lists all 100 operations and then returns 100 answers. -[!include[Excel custom functions note](../includes/excel-custom-functions-note.md)] - -## View the completed sample - -To view the completed sample, follow this article and paste the code examples into your own project. For example, to create a new custom function project for TypeScript use the [Yeoman generator for Office Add-ins](../develop/yeoman-generator-overview.md), then add all the code from this article to the project. Run the code and try it out. - -Alternatively, download or view the complete sample project at [Custom function batching pattern](https://github.com/OfficeDev/Office-Add-in-samples/tree/main/Excel-custom-functions/Batching). If you want to view the code in whole before reading any further, take a look at the [script file](https://github.com/OfficeDev/Office-Add-in-samples/blob/main/Excel-custom-functions/Batching/src/functions/functions.js). - -## Create the batching pattern in this article +## Key points To set up batching for your custom functions you'll need to write three main sections of code. @@ -28,15 +20,24 @@ To set up batching for your custom functions you'll need to write three main sec 2. A [function to make the remote request](#make-the-remote-request) when the batch is ready. 3. [Server code to respond to the batch request](#process-the-batch-call-on-the-remote-service), calculate all of the operation results, and return the values. +[!include[Excel custom functions note](../includes/excel-custom-functions-note.md)] + +## Create the batching pattern in this article + In the following sections, you'll learn how to construct the code one example at a time. It's recommended you create a brand-new custom functions project using the [Yeoman generator for Office Add-ins](../develop/yeoman-generator-overview.md) generator. To create a new project, see [Get started developing Excel custom functions](../quickstarts/excel-custom-functions-quickstart.md). You can use TypeScript or JavaScript. +> [!TIP] +> To view the completed sample, create a new custom functions project with the Yeoman generator for Office Add-ins, and then paste the code examples into your own project. Run the code and try it out. +> +> Alternatively, download or view the complete sample project at [Custom function batching pattern](https://github.com/OfficeDev/Office-Add-in-samples/tree/main/Excel-custom-functions/Batching). If you want to view the code in whole before reading any further, take a look at the [script file](https://github.com/OfficeDev/Office-Add-in-samples/blob/main/Excel-custom-functions/Batching/src/functions/functions.js). + ## Batch each call to your custom function Your custom functions work by calling a remote service to perform the operation and calculate the result they need. This provides a way for them to store each requested operation into a batch. Later you'll see how to create a `_pushOperation` function to batch the operations. First, take a look at the following code example to see how to call `_pushOperation` from your custom function. In the following code, the custom function performs division but relies on a remote service to do the actual calculation. It calls `_pushOperation` to batch the operation along with other operations to the remote service. It names the operation **div2**. You can use any naming scheme you want for operations as long as the remote service is also using the same scheme (more on the remote service later). Also, the arguments the remote service will need to run the operation are passed. -### Add the div2 custom function +### Add the `div2` custom function Add the following code to your **functions.js** or **functions.ts** file (depending on if you used JavaScript or TypeScript). @@ -176,7 +177,7 @@ Add the following code to your **functions.js** or **functions.ts** file. ```javascript // This function simulates the work of a remote service. Because each service -// differs, you will need to modify this function appropriately to work with the service you are using. +// differs, you will need to modify this function appropriately to work with the service you are using. // This function takes a batch of argument sets and returns a promise that may contain a batch of values. // NOTE: When implementing this function on a server, also apply an appropriate authentication mechanism // to ensure only the correct callers can access it. @@ -232,6 +233,18 @@ To modify the `_fetchFromRemoteService` function to run in your live remote serv - Apply an appropriate authentication mechanism. Ensure that only the correct callers can access the function. - Place the code in the remote service. +## When to avoid batching + +Batching adds a small delay and some extra code. Avoid batching in the following scenarios. + +| Scenario | Negative impact of batching | Recommendation | +|----------|-------------------|----------------| +| Single or very few calls | Extra wait for timer | Call service directly if list is still empty | +| Very large input data per call | Request might get too large | Limit size or send those calls alone | +| Some calls are much slower than others | One slow call delays faster ones | Group slow types separately | +| Need near‑instant result (less than 50 ms) | Timer adds delay | Use a shorter timer or skip batching | +| Server already combines work | No benefit | Skip batching on the client | + ## Next steps Learn about [the various parameters](custom-functions-parameter-options.md) you can use in your custom functions. Or review the basics behind making [a web call through a custom function](custom-functions-web-reqs.md). diff --git a/docs/excel/custom-functions-debugging.md b/docs/excel/custom-functions-debugging.md index d7bc30cd3..4a2a75854 100644 --- a/docs/excel/custom-functions-debugging.md +++ b/docs/excel/custom-functions-debugging.md @@ -1,14 +1,14 @@ --- title: Custom functions debugging in a non-shared runtime -description: Learn how to debug your Excel custom functions that don't use a shared runtime. -ms.date: 01/03/2024 +description: Debug Excel custom functions that don't use a shared runtime. +ms.date: 09/19/2025 ms.topic: troubleshooting ms.localizationpriority: medium --- # Custom functions debugging in a non-shared runtime -This article discusses debugging only for custom functions that **don't use a [shared runtime](../testing/runtimes.md#shared-runtime)**. To debug custom functions add-ins that use a shared runtime, see [Overview of debugging Office Add-ins](../testing/debug-add-ins-overview.md). +This article covers debugging only for custom functions that **don't use a [shared runtime](../testing/runtimes.md#shared-runtime)**. For shared runtime scenarios, see [Overview of debugging Office Add-ins](../testing/debug-add-ins-overview.md). [!include[Excel custom functions note](../includes/excel-custom-functions-note.md)] @@ -31,13 +31,13 @@ The process of debugging a custom function for add-ins that don't use a shared r ## Use the browser developer tools to debug custom functions in Excel on the web -You can use the browser developer tools to debug custom functions that don't use a shared runtime in Excel on the web. The following steps work for both Windows and macOS. +You can use the browser developer tools to debug custom functions that don't use a shared runtime in Excel on the web. The following steps work for Windows and macOS. ### Run your add-in from Visual Studio Code 1. Open your custom functions root project folder in [Visual Studio Code (VS Code)](https://code.visualstudio.com/). -1. Choose **Terminal** > **Run Task** and type or select **Watch**. This will monitor and rebuild for any file changes. -1. Choose **Terminal** > **Run Task** and type or select **Dev Server**. +1. Choose **Terminal** > **Run Task** and run **Watch**. This will monitor and rebuild for any file changes. +1. Choose **Terminal** > **Run Task** and run **Dev Server**. ### Sideload your add-in @@ -54,18 +54,18 @@ You can use the browser developer tools to debug custom functions that don't use ### Start debugging -1. Open developer tools in the browser. For Chrome and most browsers F12 will open the developer tools. +1. Open developer tools in the browser. For Chrome and most browsers F12 opens the developer tools. 1. In developer tools, open your source code script file using Cmd+P or Ctrl+P (**functions.js** or **functions.ts**). 1. [Set a breakpoint](https://code.visualstudio.com/Docs/editor/debugging#_breakpoints) in the custom function source code. -If you need to change the code you can make edits in VS Code and save the changes. Refresh the browser to see the changes loaded. +If needed, edit code in VS Code, save, then refresh the workbook page to load updates. ## Use the command line tools to debug -If you aren't using VS Code, you can use the command line (such as bash, or PowerShell) to run your add-in. You'll need to use the browser developer tools to debug your code in Excel on the web. You cannot debug the desktop version of Excel using the command line. +If you aren't using VS Code, you can use the command line such as bash or PowerShell to run your add-in. Use the browser developer tools to debug your code in Excel on the web. You cannot debug the desktop version of Excel from the command line. 1. From the command line run `npm run watch` to watch for and rebuild when code changes occur. -1. Open a second command line window (the first one will be blocked while running the watch.) +1. Open a second command line window (the first one is busy while running the watch.) 1. If you want to start your add-in in the desktop version of Excel and the "scripts" section of the project's package.json file has a "start:desktop" script, then run `npm run start:desktop`; otherwise, run `npm run start`. @@ -77,7 +77,7 @@ If you aren't using VS Code, you can use the command line (such as bash, or Powe If your add-in doesn't sideload in the document, follow the steps in [Sideload your add-in](#sideload-your-add-in) to sideload your add-in. Then continue to the next section to start debugging. -1. Open developer tools in the browser. For Chrome and most browsers F12 will open the developer tools. +1. Open developer tools in the browser. For Chrome and most browsers F12 opens the developer tools. 1. In developer tools, open your source code script file (**functions.js** or **functions.ts**). Your custom functions code may be located near the end of the file. 1. In the custom function source code, apply a breakpoint by selecting a line of code. @@ -85,14 +85,14 @@ If you need to change the code, you can make edits in VS Code and save the chang ### Commands for building and running your add-in -There are several build tasks available. +Available build tasks: - `npm run watch`: builds for development and automatically rebuilds when a source file is saved - `npm run build-dev`: builds for development once - `npm run build`: builds for production - `npm run dev-server`: runs the web server used for development -You can use the following tasks to start debugging on desktop or online. +Use these tasks to start debugging: - `npm run start:desktop`: Starts Excel on desktop and sideloads your add-in. If the "start:desktop" script isn't present in the "scripts" section of the project's package.json file, then run `npm run start` instead. - `npm run start -- web --document {url}` (where `{url}` is the URL of an Excel file on OneDrive or SharePoint): Starts Excel on the web and sideloads your add-in. diff --git a/docs/excel/custom-functions-errors.md b/docs/excel/custom-functions-errors.md index 0c4f9a18b..e7d1c2da2 100644 --- a/docs/excel/custom-functions-errors.md +++ b/docs/excel/custom-functions-errors.md @@ -1,24 +1,24 @@ --- title: Handle and return errors from your custom function -description: 'Handle and return errors like #NULL! from your custom function.' -ms.date: 08/12/2021 +description: 'Return meaningful Excel errors (like #VALUE! and #N/A) from custom functions and map exceptions to user-friendly messages.' +ms.date: 09/19/2025 ms.localizationpriority: medium --- # Handle and return errors from your custom function -If something goes wrong while your custom function runs, return an error to inform the user. If you have specific parameter requirements, such as only positive numbers, test the parameters and throw an error if they aren't correct. You can also use a [`try...catch`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/try...catch) block to catch any errors that occur while your custom function runs. +When a custom function encounters invalid input, an unavailable resource, or a computation failure, return the most specific Excel error possible. Validate parameters early to fail promptly and wrap external calls in `try...catch` blocks to translate low-level exceptions into meaningful Excel errors. ## Detect and throw an error -Let's look at a case where you need to ensure that a zip code parameter is in the correct format for the custom function to work. The following custom function uses a regular expression to check the zip code. If the zip code format is correct, then it will look up the city using another function and return the value. If the format isn't valid, the function returns a `#VALUE!` error to the cell. +The following example validates a U.S. ZIP Code with a regular expression before it proceeds. If the format is invalid, it throws a `#VALUE!` error. ```typescript /** -* Gets a city name for the given U.S. zip code. +* Gets a city name for the given U.S. ZIP Code. * @customfunction * @param {string} zipCode -* @returns The city of the zip code. +* @returns The city of the ZIP Code. */ function getCity(zipCode: string): string { let isValidZip = /(^\d{5}$)|(^\d{5}-\d{4}$)/.test(zipCode); @@ -30,7 +30,7 @@ function getCity(zipCode: string): string { ## The CustomFunctions.Error object -The [CustomFunctions.Error](/javascript/api/custom-functions-runtime/customfunctions.error) object is used to return an error back to the cell. When you create the object, specify which error you want to use by choosing one of the following `ErrorCode` enum values. +The [CustomFunctions.Error](/javascript/api/custom-functions-runtime/customfunctions.error) object returns an error to the cell. Specify which error by choosing an `ErrorCode` value from the following list. |ErrorCode enum value |Excel cell value |Description | |---------------|---------|---------| @@ -59,7 +59,7 @@ throw error; ### Handle errors when working with dynamic arrays -In addition to returning a single error, a custom function can output a dynamic array that includes an error. For example, a custom function could output the array `[1],[#NUM!],[3]`. The following code sample shows how to input three parameters into a custom function, replace one of the input parameters with a `#NUM!` error, and then return a 2-dimensional array with the results of processing each input parameter. +You can return dynamic arrays that contain errors. For example, a custom function could output the array `[1],[#NUM!],[3]`. The following code sample shows how to input three parameters into a custom function, replace one of the input parameters with a `#NUM!` error, and then return a 2-dimensional array with the results of processing each input parameter. ```js /** @@ -98,7 +98,7 @@ To process inputs that contain errors, a custom function must have the JSON meta ## Use `try...catch` blocks -In general, use [`try...catch`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/try...catch) blocks in your custom function to catch any potential errors that occur. If you don't handle exceptions in your code, they will be returned to Excel. By default, Excel returns `#VALUE!` for unhandled errors or exceptions. +Use [`try...catch`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/try...catch) blocks to catch potential errors and return meaningful error messages to your users. By default, Excel returns `#VALUE!` for unhandled errors or exceptions. In the following code sample, the custom function makes a fetch call to a REST service. It's possible that the call will fail, for example, if the REST service returns an error or the network goes down. If this happens, the custom function will return `#N/A` to indicate that the web call failed. diff --git a/docs/excel/custom-functions-naming.md b/docs/excel/custom-functions-naming.md index 06053a802..ec68356af 100644 --- a/docs/excel/custom-functions-naming.md +++ b/docs/excel/custom-functions-naming.md @@ -1,75 +1,101 @@ --- title: Naming and localization for custom functions in Excel description: Learn requirements for names of Excel custom functions and how to localize custom functions. -ms.date: 02/29/2024 +ms.date: 09/22/2025 ms.localizationpriority: medium --- + # Custom functions naming and localization -This article describes guidelines and best practices for naming custom functions. It also shows how to localize custom function names to languages other than English. +This article lists simple rules and tips for naming custom functions and shows how to localize them. ## Custom functions naming guidelines -A custom function is identified by an `id` and `name` property in the JSON metadata file. +A custom function is identified by an `id` and a `name` in the JSON metadata. -- The function `id` is used to uniquely identify custom functions in your JavaScript code. -- The function `name` is used as the display name that appears to a user in Excel. +- `id`: Unique identifier used in code. Keep it stable. +- `name`: Display name shown to users. It can be localized. [!include[Excel custom functions note](../includes/excel-custom-functions-note.md)] -A function `name` can differ from the function `id`, such as for localization purposes. In general, a function's `name` should stay the same as the `id` if there is no reason for them to differ. - -A function's `name` and `id` share some common requirements. - -- A function's `id` may only use characters A through Z, numbers zero through nine, underscores, and periods. +A function `name` can differ from the `id` for localization. If you don't need localization, using the same value is recommended. -- A function's `name` may use any Unicode alphabetic characters, underscores, and periods. +A function's `name` and `id` share some similar rules. -- Both function `name` and `id` must start with a letter and have a minimum limit of three characters. +- Both must start with a letter and be at least three characters. +- `id`: Only A–Z, 0–9, underscore, and period characters allowed. +- `name`: Any Unicode letters, underscore, and period characters allowed. -Excel uses uppercase letters for built-in function names (such as `SUM`). Use uppercase letters for your custom function's `name` and `id` as a best practice. +Excel shows built‑in function names in uppercase letters (such as `SUM`). Using uppercase helps your custom functions fit in. -A function's `name` shouldn't be the same as: +Avoid names that match: -- Any cells between A1 to XFD1048576 or any cells between R1C1 to R1048576C16384. - -- Any Excel 4.0 Macro Function (such as `RUN`, `ECHO`). For a full list of these functions, see [this Excel Macro Functions Reference document](https://www.myonlinetraininghub.com/cdn/files/Excel%204.0%20Macro%20Functions%20Reference.pdf). +- A cell reference (A1 to XFD1048576 or R1C1 style). +- An Excel 4.0 Macro Function (such as `RUN`, `ECHO`). For a full list of these functions, see [this Excel Macro Functions Reference document](https://www.myonlinetraininghub.com/cdn/files/Excel%204.0%20Macro%20Functions%20Reference.pdf). ## Naming conflicts -If your function `name` is the same as a function `name` in an add-in that already exists, the **#REF!** error will appear in your workbook. +If your function `name` conflicts with one from another add‑in, Excel shows the **#REF!** error. -To fix a naming conflict, change the `name` in your add-in and try the function again. You can also uninstall the add-in with the conflicting name. Or, if you're testing your add-in in different environments, try using a different namespace to differentiate your function (such as `NAMESPACE_NAMEOFFUNCTION`). +Fix conflicts by renaming your function or uninstalling the other add‑in. For testing in multiple environments, use a short namespace prefix (such as `ACME_FUNCTIONNAME`). ## Best practices -- Consider adding multiple arguments to a function rather than creating multiple functions with the same or similar names. -- Avoid ambiguous abbreviations in function names. Clarity is more important than brevity. Choose a name like `=INCREASETIME` rather than `=INC`. -- Function names should indicate the action of the function, such as =GETZIPCODE instead of ZIPCODE. -- Consistently use the same verbs for functions which perform similar actions. For example, use `=DELETEZIPCODE` and `=DELETEADDRESS`, rather than `=DELETEZIPCODE` and `=REMOVEADDRESS`. -- When naming a streaming function, consider adding a note to that effect in the description of the function or adding `STREAM` to the end of the function's name. +- Prefer extra function arguments over multiple near-duplicate function names. +- Avoid unclear abbreviations (`INCREASETIME` is clearer than `INC`). +- Use action verbs (`GETZIPCODE` not just `ZIPCODE`). +- Be consistent: Use the same verb for similar actions (`DELETEZIPCODE`, `DELETEADDRESS`). +- Consider adding `STREAM` or a note in the description for streaming functions. [!include[manifest guidance](../includes/manifest-guidance.md)] +## Naming constraints quick reference + +| Aspect | `id` | `name` | Notes | +|--------|------|-------|-------| +| Allowed characters | A–Z 0–9 `_` `.` | Unicode letters `_` `.` | Keep `id` simple. Localize `name`. | +| Starts with letter | Yes | Yes | Avoids cell reference confusion. | +| Minimum length | 3 | 3 | Short names reduce clarity. | +| Case style | Uppercase recommended | Uppercase recommended | Matches Excel style. | +| Localizable | No | Yes | Keep `id` stable. Localize `name` as needed. | +| Can mimic cell address | No | No | Prevent address parsing errors. | +| Reserved macro names | Disallowed | Disallowed | Some examples: `RUN`, `ECHO`. | + +### Invalid `id` and `name` examples + +| `id` | `name` | Reason | +|------|--------|--------| +| `1ADD` | `1ADD` | Starts with digit. | +| `A` | `A` | Too short (less than 3 characters). | +| `SUM` | `SUM` | Built‑in Excel formula name. | +| `MÜLTIPLY` | `MÜLTIPLY` | Non-ASCII letter in `id`. | +| `GET-VALUE` | `GET-VALUE` | Hyphen not allowed. Use underscore instead. | +| `RUN` | `RUN` | Reserved macro name. | +| `A1R1` | `A1R1` | Looks like a cell reference. | + +### Recommended namespace pattern + +For many functions, add a short vendor prefix such as `CONTOSO_GETPRICE` or `CONTOSO_TAX_CALC` to reduce conflicts with other add-ins. + ## Localize custom functions -You can localize both your add-in and your custom function names. To do so, provide localized function names in the functions' JSON file and locale information in the add-in only manifest file. +You can localize both your add-in and your custom function names. Add localized function names in JSON and locale overrides in the add-in only manifest. > [!IMPORTANT] > Autogenerated metadata doesn't work for localization so you need to update the JSON file manually. To learn how to do this, see [Manually create JSON metadata for custom functions](custom-functions-json.md). ### Localize function names -To localize your custom functions, create a new JSON metadata file for each language. In each language JSON file, add `name` and `description` properties in the target language. The default file for English is named **functions.json**. Use the locale in the filename for each additional JSON file, such as **functions-de.json** to help identify them. +Create one JSON metadata file per language. In each, localize `name` and `description`. The default English file is **functions.json**. Add locale tags to new files, like **functions-de.json**. -The `name` and `description` appear in Excel and are localized. However, the `id` of each function isn't localized. The `id` property is how Excel identifies your function as unique and shouldn't be changed once it is set. +Excel localizes `name` and `description`. The `id` stays fixed and should not change once it's set. > [!IMPORTANT] -> Avoid giving your functions an `id` or `name` that is a built-in Excel function in another language as this conflicts with localized functions. +> Avoid an `id` or `name` that matches a built‑in Excel function in any language. The following JSON shows how to define a function with the `id` property "MULTIPLY". The `name` and `description` property of the function is localized for German. Each parameter `name` and `description` is also localized for German. -```JSON +```json { "id": "MULTIPLY", "name": "SUMME", @@ -89,17 +115,17 @@ The following JSON shows how to define a function with the `id` property "MULTIP "name": "zwei", "description": "Zweite Nummer", "dimensionality": "scalar" - }, - ], + } + ] } ``` Compare the previous JSON with the following JSON for English. -```JSON +```json { "id": "MULTIPLY", - "name": "Multiply", + "name": "MULTIPLY", "description": "Multiplies two numbers", "helpUrl": "http://www.contoso.com", "result": { @@ -109,21 +135,21 @@ Compare the previous JSON with the following JSON for English. "parameters": [ { "name": "one", - "description": "first number", + "description": "First number", "dimensionality": "scalar" }, { "name": "two", - "description": "second number", + "description": "Second number", "dimensionality": "scalar" - }, - ], + } + ] } ``` ### Localize your add-in -After creating a JSON file for each language, update your add-in only manifest file with an override value for each locale that specifies the URL of each JSON metadata file. The following manifest XML shows a default `en-us` locale with an override JSON file URL for `de-de` (Germany). The **functions-de.json** file contains the localized German function names and IDs. +After creating each language file, add a manifest override that points to that file. The following manifest XML shows a default `en-us` locale plus an override JSON file for `de-de` (Germany). ```XML en-us diff --git a/docs/excel/custom-functions-runtime.md b/docs/excel/custom-functions-runtime.md index ae3fd2d87..383101e13 100644 --- a/docs/excel/custom-functions-runtime.md +++ b/docs/excel/custom-functions-runtime.md @@ -1,5 +1,5 @@ --- -ms.date: 06/15/2022 +ms.date: 09/22/2025 description: Understand Excel custom functions that don't use a shared runtime and their specific JavaScript-only runtime. title: JavaScript-only runtime for custom functions ms.localizationpriority: medium @@ -7,7 +7,7 @@ ms.localizationpriority: medium # JavaScript-only runtime for custom functions -Custom functions that don't use a shared runtime use a [JavaScript-only runtime](../testing/runtimes.md#javascript-only-runtime) that is designed to optimize performance of calculations. +Custom functions that don't use a shared runtime instead use a [JavaScript-only runtime](../testing/runtimes.md#javascript-only-runtime) that's focused on fast calculation and has fewer APIs available. [!include[Excel custom functions note](../includes/excel-custom-functions-note.md)] @@ -59,6 +59,10 @@ function StoreValue(key, value) { } ``` +## Compare with shared runtime + +Need UI integration, richer Office.js objects, or advanced events? Move those functions to a [shared runtime](../testing/runtimes.md#shared-runtime) so they can use those features. + ## Next steps Learn how to [debug custom functions](custom-functions-debugging.md). diff --git a/docs/excel/performance.md b/docs/excel/performance.md index 60ef08f5f..1ff72a60c 100644 --- a/docs/excel/performance.md +++ b/docs/excel/performance.md @@ -266,4 +266,4 @@ async function run() { - [Excel JavaScript object model in Office Add-ins](excel-add-ins-core-concepts.md) - [Error handling with the application-specific JavaScript APIs](../testing/application-specific-api-error-handling.md) -- [Worksheet Functions Object (JavaScript API for Excel)](/javascript/api/excel/excel.functions) \ No newline at end of file +- [Worksheet Functions Object (JavaScript API for Excel)](/javascript/api/excel/excel.functions)