---
product: Chilkat
product_version: 11.7.0
language: asp
language_label: Classic ASP
class: JsonArray
license: free
deprecated: false
reference_html: https://www.chilkatsoft.com/refdoc/asp_JsonArrayRef.html
---
# Chilkat JsonArray — Classic ASP — v11.7.0

> Chilkat 11.7.0 · language=asp · class=JsonArray
> Other versions: replace `11.7.0` in this URL. Other languages: `https://www.chilkatsoft.com/ai-docs/v/11.7.0/<lang>/classes/JsonArray.md`.
> Language-wide rules (install, unlock, error model, strings/bytes): `https://www.chilkatsoft.com/ai-docs/v/11.7.0/asp/guide.md`.

## Purpose

**Read, modify, search, and emit ordered JSON arrays.**

`Chilkat.JsonArray` is the JSON array companion to `Chilkat.JsonObject`. It represents an ordered list of JSON values and provides index-based methods for reading, inserting, replacing, deleting, swapping, searching, and emitting array data. It supports scalar values, nested objects, nested arrays, date/time parsing, exact numeric string handling, compact or pretty output, and search helpers for arrays of strings or arrays of objects.

**Ordered JSON values**

Work with JSON arrays as ordered lists containing strings, numbers, booleans, nulls, objects, arrays, and mixed value types.

**Index-based access**

Retrieve, insert, replace, delete, or swap values by array index when processing JSON list data.

**Nested objects and arrays**

Access child `JsonObject` and `JsonArray` values to navigate and modify deeper JSON structures.

**Search helpers**

Search arrays of strings or arrays of objects to locate matching values without manually scanning every element.

**Date and numeric handling**

Parse date/time values and preserve exact numeric strings when JSON data contains values that must not be rounded or reformatted.

**Emit JSON output**

Produce compact or pretty JSON output after array data has been loaded, edited, searched, or built programmatically.

**Common pattern:** Use `JsonObject` to navigate named members and JSON paths, then use `JsonArray` to iterate or modify ordered lists found within the object tree. Retrieve nested objects or arrays as needed, update values by index, and emit the final JSON in compact or pretty form.

For an extended overview, see [JsonArray Class Overview](https://www.chilkatsoft.com/jsonarray_class_overview.asp).

## Object creation, unlocking and error handling

**Object Creation**

```visual-basic
set jsonArray = Server.CreateObject("Chilkat.JsonArray")

' ... use jsonArray ...

set jsonArray = Nothing
```

Classic ASP creates Chilkat objects with `Server.CreateObject`. The registered Chilkat ActiveX must match the bitness of the IIS application pool: a pool with *Enable 32-Bit Applications* set to True needs the 32-bit ActiveX, otherwise the 64-bit ActiveX. To bind to a specific major version of Chilkat, append the major version number to the ProgID, such as `Server.CreateObject("Chilkat.JsonArray.11")` for Chilkat v11.\*.\*.

VBScript requires `set` when assigning an object, so the signatures on this page show `set x = obj.Method(...)` for methods that return a Chilkat object; test the result with `Is Nothing`, since a method that fails to return an object returns `Nothing`. A method with no return value is called as a statement without parentheses (`obj.Method arg1, arg2`). Boolean properties, arguments and return values are integers in the ActiveX: pass `1` or `0`, and test success with `= 1`. Byte arrays are Variant arrays and can be sent with `Response.BinaryWrite`. Asynchronous (*\*Async*) methods and event callbacks are not used from Classic ASP.

Call `Global.UnlockBundle` once at the start of the program, before using this or any other Chilkat class. Any string unlocks a fully functional 30-day trial; a purchased unlock code is used in production. See `guide.md` for the exact code in Classic ASP.

How failure is reported depends on the method's return type and is stated in the note under each method below. In every case the diagnostic text is in the `LastErrorText` property of the object whose method was called.

## Members common to every Chilkat class

Documented once per language in `common-members.md`; listed here so this page is self-contained.

| Property | Signature | Access | Meaning |
|---|---|---|---|
| `DebugLogFilePath` | `jsonArray.DebugLogFilePath ' String` | read/write | If set to a file path, this property logs the LastErrorText of each Chilkat method or property call to the specified file. |
| `LastBinaryResult` | `jsonArray.LastBinaryResult ' Variant (read-only)` | read-only | This property is mainly used in SQL Server stored procedures to retrieve binary data from the last method call that returned binary data. |
| `LastErrorHtml` | `jsonArray.LastErrorHtml ' String (read-only)` | read-only | Provides HTML-formatted information about the last called method or property. |
| `LastErrorText` | `jsonArray.LastErrorText ' String (read-only)` | read-only | Provides plain text information about the last called method or property. |
| `LastErrorXml` | `jsonArray.LastErrorXml ' String (read-only)` | read-only | Provides XML-formatted information about the last called method or property. |
| `LastMethodSuccess` | `jsonArray.LastMethodSuccess ' Long` | read/write | Indicates the success or failure of the most recent method call: `1` means success, `0` means failure. |
| `LastStringResult` | `jsonArray.LastStringResult ' String (read-only)` | read-only | In SQL Server stored procedures, this property holds the string return value of the most recent method call that returns a string. |
| `LastStringResultLen` | `jsonArray.LastStringResultLen ' Long (read-only)` | read-only | The length, in characters, of the string contained in the LastStringResult property. |
| `VerboseLogging` | `jsonArray.VerboseLogging ' Long` | read/write | If set to `1`, then the contents of LastErrorText (or LastErrorXml, or LastErrorHtml) may contain more verbose information. |
| `Version` | `jsonArray.Version ' String (read-only)` | read-only | Version of the component/library, such as "10.1.0" |

## Member index

| Member | Kind | Signature |
|---|---|---|
| `EmitCompact` | property, read/write | `jsonArray.EmitCompact ' Long` |
| `EmitCrlf` | property, read/write | `jsonArray.EmitCrlf ' Long` |
| `FindStartIndex` | property, read/write | `jsonArray.FindStartIndex ' Long` |
| `Size` | property, read-only | `jsonArray.Size ' Long (read-only)` |
| `AddArrayAt` | method | `success = jsonArray.AddArrayAt(index) ' Long (1/0)` |
| `AddArrayAt2` | method | `success = jsonArray.AddArrayAt2(index, jarr) ' Long (1/0)` |
| `AddBoolAt` | method | `success = jsonArray.AddBoolAt(index, value) ' Long (1/0)` |
| `AddIntAt` | method | `success = jsonArray.AddIntAt(index, value) ' Long (1/0)` |
| `AddNullAt` | method | `success = jsonArray.AddNullAt(index) ' Long (1/0)` |
| `AddNumberAt` | method | `success = jsonArray.AddNumberAt(index, numericStr) ' Long (1/0)` |
| `AddObjectAt` | method | `success = jsonArray.AddObjectAt(index) ' Long (1/0)` |
| `AddObjectAt2` | method | `success = jsonArray.AddObjectAt2(index, json) ' Long (1/0)` |
| `AddObjectCopyAt` | method | `success = jsonArray.AddObjectCopyAt(index, jsonObj) ' Long (1/0)` |
| `AddStringAt` | method | `success = jsonArray.AddStringAt(index, value) ' Long (1/0)` |
| `AddUIntAt` | method | `success = jsonArray.AddUIntAt(index, value) ' Long (1/0)` |
| `AppendArrayItems` | method | `success = jsonArray.AppendArrayItems(jarr) ' Long (1/0)` |
| `ArrayAt` | method | `set jsonArray = jsonArray.ArrayAt(index) ' ChilkatJsonArray` |
| `ArrayAt2` | method | `success = jsonArray.ArrayAt2(index, jarr) ' Long (1/0)` |
| `BoolAt` | method | `success = jsonArray.BoolAt(index) ' Long (1/0)` |
| `Clear` | method | `jsonArray.Clear` |
| `DateAt` | method | `success = jsonArray.DateAt(index, dt) ' Long (1/0)` |
| `DeleteAt` | method | `success = jsonArray.DeleteAt(index) ' Long (1/0)` |
| `DtAt` | method | `success = jsonArray.DtAt(index, bLocal, dt) ' Long (1/0)` |
| `Emit` | method | `str = jsonArray.Emit() ' String` |
| `EmitSb` | method | `success = jsonArray.EmitSb(sb) ' Long (1/0)` |
| `FindObject` | method | `n = jsonArray.FindObject(name, value, caseSensitive) ' Long` |
| `FindString` | method | `n = jsonArray.FindString(value, caseSensitive) ' Long` |
| `IntAt` | method | `n = jsonArray.IntAt(index) ' Long` |
| `IsNullAt` | method | `success = jsonArray.IsNullAt(index) ' Long (1/0)` |
| `Load` | method | `success = jsonArray.Load(jsonArray) ' Long (1/0)` |
| `LoadSb` | method | `success = jsonArray.LoadSb(sb) ' Long (1/0)` |
| `ObjectAt` | method | `set jsonObject = jsonArray.ObjectAt(index) ' ChilkatJsonObject` |
| `ObjectAt2` | method | `success = jsonArray.ObjectAt2(index, jsonObj) ' Long (1/0)` |
| `SetBoolAt` | method | `success = jsonArray.SetBoolAt(index, value) ' Long (1/0)` |
| `SetIntAt` | method | `success = jsonArray.SetIntAt(index, value) ' Long (1/0)` |
| `SetNullAt` | method | `success = jsonArray.SetNullAt(index) ' Long (1/0)` |
| `SetNumberAt` | method | `success = jsonArray.SetNumberAt(index, value) ' Long (1/0)` |
| `SetStringAt` | method | `success = jsonArray.SetStringAt(index, value) ' Long (1/0)` |
| `SetUIntAt` | method | `success = jsonArray.SetUIntAt(index, value) ' Long (1/0)` |
| `StringAt` | method | `str = jsonArray.StringAt(index) ' String` |
| `Swap` | method | `success = jsonArray.Swap(index1, index2) ' Long (1/0)` |
| `TypeAt` | method | `n = jsonArray.TypeAt(index) ' Long` |
| `UIntAt` | method | `n = jsonArray.UIntAt(index) ' Long` |

## Properties

### JsonArray.EmitCompact

`Chilkat 11.7.0 · asp · JsonArray · EmitCompact · property · read/write · since 9.5.0.64`

```visual-basic
jsonArray.EmitCompact  ' Long
```

Controls whether emitted JSON is compact or pretty-formatted. If `1`, output contains no unnecessary whitespace and is emitted on a single line. If `0`, indentation and line breaks are added for readability. The default is `1`.

### JsonArray.EmitCrlf

`Chilkat 11.7.0 · asp · JsonArray · EmitCrlf · property · read/write · since 9.5.0.64`

```visual-basic
jsonArray.EmitCrlf  ' Long
```

Controls line endings when pretty-formatted JSON is emitted. If `1`, line breaks use CRLF (); if `0`, they use LF (). The default is `1`.

**Applies only to pretty output:** When `EmitCompact` is `1`, the JSON is emitted on one line and this setting has no effect.

### JsonArray.FindStartIndex

`Chilkat 11.7.0 · asp · JsonArray · FindStartIndex · property · read/write · since 11.6.0`

```visual-basic
jsonArray.FindStartIndex  ' Long
```

Specifies the zero-based array index at which `FindString` and `FindObject` begin searching. The default value is `0`.

**Iterating matches:** After finding a match at index `n`, set this property to `n + 1` before the next search to continue with later elements.

### JsonArray.Size

`Chilkat 11.7.0 · asp · JsonArray · Size · property · read-only · since 9.5.0.56`

```visual-basic
jsonArray.Size  ' Long (read-only)
```

Returns the number of values currently contained in the JSON array. Array indexes therefore range from `0` through `Size - 1`.

## Methods

### JsonArray.AddArrayAt

`Chilkat 11.7.0 · asp · JsonArray · AddArrayAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddArrayAt(index)  ' Long (1/0)
```

Inserts a new, empty JSON array at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddArrayAt2

`Chilkat 11.7.0 · asp · JsonArray · AddArrayAt2 · method · since 11.1.0`

```visual-basic
success = jsonArray.AddArrayAt2(index, jarr)  ' Long (1/0)
```

Inserts a new, empty JSON array at zero-based position `index` and updates `jarr` to reference the newly inserted array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Immediate editing:** Because `jarr` references the inserted array, it can be populated directly without a separate `ArrayAt` lookup.

Returns 1 for success, 0 for failure.

### JsonArray.AddBoolAt

`Chilkat 11.7.0 · asp · JsonArray · AddBoolAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddBoolAt(index, value)  ' Long (1/0)
```

Inserts a new JSON boolean value at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddIntAt

`Chilkat 11.7.0 · asp · JsonArray · AddIntAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddIntAt(index, value)  ' Long (1/0)
```

Inserts a new JSON integer value at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddNullAt

`Chilkat 11.7.0 · asp · JsonArray · AddNullAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddNullAt(index)  ' Long (1/0)
```

Inserts a JSON `null` value at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddNumberAt

`Chilkat 11.7.0 · asp · JsonArray · AddNumberAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddNumberAt(index, numericStr)  ' Long (1/0)
```

Inserts a JSON number at zero-based position `index`. The `numericStr` argument supplies the exact JSON numeric text to store. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Exact numeric text:** Use this method when lexical form or precision matters, for example `12345678901234567890`, `1.2500`, or scientific notation. The supplied text must be valid JSON number syntax; JSON does not permit `NaN` or infinity.

Returns 1 for success, 0 for failure.

### JsonArray.AddObjectAt

`Chilkat 11.7.0 · asp · JsonArray · AddObjectAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddObjectAt(index)  ' Long (1/0)
```

Inserts a new, empty JSON object at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddObjectAt2

`Chilkat 11.7.0 · asp · JsonArray · AddObjectAt2 · method · since 11.1.0`

```visual-basic
success = jsonArray.AddObjectAt2(index, json)  ' Long (1/0)
```

Inserts a new, empty JSON object at zero-based position `index` and updates `json` to reference the newly inserted object.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Immediate editing:** Because `json` references the inserted object, it can be populated directly without a separate `ObjectAt` lookup.

Returns 1 for success, 0 for failure.

### JsonArray.AddObjectCopyAt

`Chilkat 11.7.0 · asp · JsonArray · AddObjectCopyAt · method · since 9.5.0.82`

```visual-basic
success = jsonArray.AddObjectCopyAt(index, jsonObj)  ' Long (1/0)
```

Inserts an independent copy of `jsonObj` at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Copy semantics:** The inserted object is copied rather than referenced. Later changes to the source `jsonObj` do not serve as edits to the inserted array value.

Returns 1 for success, 0 for failure.

### JsonArray.AddStringAt

`Chilkat 11.7.0 · asp · JsonArray · AddStringAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.AddStringAt(index, value)  ' Long (1/0)
```

Inserts a new JSON string value at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AddUIntAt

`Chilkat 11.7.0 · asp · JsonArray · AddUIntAt · method · since 9.5.0.96`

```visual-basic
success = jsonArray.AddUIntAt(index, value)  ' Long (1/0)
```

Inserts a new JSON unsigned integer value at zero-based position `index`. Existing elements at that position and after it are shifted one position toward the end of the array.

|  |  |
| --- | --- |
| `0` | Insert as the first array element. |
| `-1` | Append as the last array element. |
| `n` | Insert at zero-based position n. |

**Insert vs. replace:** The `Add*At` methods insert a new array element. Use the corresponding `Set*At` method when replacing an existing element.

Returns 1 for success, 0 for failure.

### JsonArray.AppendArrayItems

`Chilkat 11.7.0 · asp · JsonArray · AppendArrayItems · method · since 9.5.0.82`

```visual-basic
success = jsonArray.AppendArrayItems(jarr)  ' Long (1/0)
```

Appends copies of all values from `jarr` to the end of this array, preserving their order.

**Source is unchanged:** The source array is not emptied or moved. This method is useful for concatenating JSON arrays, including arrays belonging to different JSON documents.

Returns 1 for success, 0 for failure.

### JsonArray.ArrayAt

`Chilkat 11.7.0 · asp · JsonArray · ArrayAt · method · since 9.5.0.56`

```visual-basic
set jsonArray = jsonArray.ArrayAt(index)  ' ChilkatJsonArray
```

Returns the nested JSON array stored at zero-based position `index`.

**Reference, not copy:** The returned `JsonArray` refers to the existing nested array in the same JSON document. Changes made through the returned object modify that nested array.

**Type requirement:** The value at `index` must be an array. Use `TypeAt` when the value type is not already known.

Returns `Nothing` on failure

### JsonArray.ArrayAt2

`Chilkat 11.7.0 · asp · JsonArray · ArrayAt2 · method · since 11.0.0`

```visual-basic
success = jsonArray.ArrayAt2(index, jarr)  ' Long (1/0)
```

Updates `jarr` so that it references the nested JSON array stored at zero-based position `index`.

**Reference, not copy:** Changes made through `jarr` modify the existing nested array in the same JSON document.

Returns 1 for success, 0 for failure.

### JsonArray.BoolAt

`Chilkat 11.7.0 · asp · JsonArray · BoolAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.BoolAt(index)  ' Long (1/0)
```

Returns the boolean value stored at zero-based position `index`.

**Type-aware access:** Use `TypeAt` when the JSON type at `index` is not already known.

### JsonArray.Clear

`Chilkat 11.7.0 · asp · JsonArray · Clear · method · since 9.5.0.76`

```visual-basic
jsonArray.Clear
```

Removes all values from the array, leaving an empty JSON array (`[]`).

### JsonArray.DateAt

`Chilkat 11.7.0 · asp · JsonArray · DateAt · method · since 9.5.0.73`

```visual-basic
success = jsonArray.DateAt(index, dt)  ' Long (1/0)
```

Parses the date/time value at zero-based position `index` and loads the result into `dt`. Recognized forms include ISO 8601 timestamps (for example, `2009-11-04T19:55:41Z`), RFC 822-style date/time strings, and Unix timestamp integers.

**JSON has no native date type:** Dates are application conventions represented as strings or numbers. These methods recognize common representations and convert them to Chilkat date/time objects.

Returns 1 for success, 0 for failure.

### JsonArray.DeleteAt

`Chilkat 11.7.0 · asp · JsonArray · DeleteAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.DeleteAt(index)  ' Long (1/0)
```

Deletes the value at zero-based position `index`. Elements following the deleted value shift down by one position.

Returns 1 for success, 0 for failure.

### JsonArray.DtAt

`Chilkat 11.7.0 · asp · JsonArray · DtAt · method · since 9.5.0.73`

```visual-basic
success = jsonArray.DtAt(index, bLocal, dt)  ' Long (1/0)
```

Parses the date/time value at zero-based position `index` and loads the result into `dt`. If `bLocal` is `1`, the populated fields represent local time; if `0`, they represent UTC/GMT. Recognized forms include ISO 8601 timestamps, RFC 822-style date/time strings, and Unix timestamp integers.

**JSON has no native date type:** Dates are application conventions represented as strings or numbers. These methods recognize common representations and convert them to Chilkat date/time objects.

Returns 1 for success, 0 for failure.

### JsonArray.Emit

`Chilkat 11.7.0 · asp · JsonArray · Emit · method · since 9.5.0.58`

```visual-basic
str = jsonArray.Emit()  ' String
```

Serializes this JSON array and returns the resulting JSON text.

**Formatting:** Set `EmitCompact` to choose compact versus pretty output. When pretty output is enabled, `EmitCrlf` selects CRLF or LF line endings.

Returns `Nothing` on failure

### JsonArray.EmitSb

`Chilkat 11.7.0 · asp · JsonArray · EmitSb · method · since 9.5.0.65`

```visual-basic
success = jsonArray.EmitSb(sb)  ' Long (1/0)
```

Serializes this JSON array into the supplied `StringBuilder`.

**Formatting:** Set `EmitCompact` to choose compact versus pretty output. When pretty output is enabled, `EmitCrlf` selects CRLF or LF line endings.

**Large JSON:** Using a `StringBuilder` can avoid returning a very large JSON document as a language-native string before passing it to another Chilkat method or writing it to a file.

Returns 1 for success, 0 for failure.

### JsonArray.FindObject

`Chilkat 11.7.0 · asp · JsonArray · FindObject · method · since 9.5.0.73`

```visual-basic
n = jsonArray.FindObject(name, value, caseSensitive)  ' Long
```

Searches array elements that are JSON objects and returns the zero-based index of the first object whose direct member `name` has a value matching `value`. Returns `-1` if no match is found. The value pattern may contain `*`, which matches zero or more characters. Set `caseSensitive` to control whether letter case must match.

**Member name, not JSON path:** `name` identifies a direct member of each object being tested; it is not a JSON path.

**Search start:** Searching begins at `FindStartIndex`, whose default is `0`. To continue searching after a match, set `FindStartIndex` to the previous returned index plus 1.

### JsonArray.FindString

`Chilkat 11.7.0 · asp · JsonArray · FindString · method · since 9.5.0.73`

```visual-basic
n = jsonArray.FindString(value, caseSensitive)  ' Long
```

Searches for the first string array element matching `value` and returns its zero-based index, or `-1` if no match is found. The pattern may contain `*`, which matches zero or more characters. Set `caseSensitive` to control whether letter case must match.

**Search start:** Searching begins at `FindStartIndex`, whose default is `0`. To continue searching after a match, set `FindStartIndex` to the previous returned index plus 1.

### JsonArray.IntAt

`Chilkat 11.7.0 · asp · JsonArray · IntAt · method · since 9.5.0.56`

```visual-basic
n = jsonArray.IntAt(index)  ' Long
```

Returns the integer value stored at zero-based position `index`.

**Type-aware access:** Use `TypeAt` when the JSON type at `index` is not already known.

### JsonArray.IsNullAt

`Chilkat 11.7.0 · asp · JsonArray · IsNullAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.IsNullAt(index)  ' Long (1/0)
```

Returns `1` if the value at zero-based position `index` is the JSON value `null`; otherwise returns `0`.

**JSON null:** `null` is a distinct JSON value. It is not the same as an empty string, zero, `false`, an empty object, or an empty array.

### JsonArray.Load

`Chilkat 11.7.0 · asp · JsonArray · Load · method · since 9.5.0.64`

```visual-basic
success = jsonArray.Load(jsonArray)  ' Long (1/0)
```

Parses the JSON array text in `jsonArray` and loads it into this object. The input must represent a JSON array, beginning with `[` and ending with `]`.

**Important — loading detaches the array:** Calling this method makes the `JsonArray` its own independent JSON document. If the object previously referenced an array nested inside another JSON document, that relationship is discarded. For this reason, call `Load`/`LoadSb` on a new `JsonArray` instance.

Returns 1 for success, 0 for failure.

### JsonArray.LoadSb

`Chilkat 11.7.0 · asp · JsonArray · LoadSb · method · since 9.5.0.64`

```visual-basic
success = jsonArray.LoadSb(sb)  ' Long (1/0)
```

Parses the JSON array contained in `sb` and loads it into this object. The input must represent a JSON array, beginning with `[` and ending with `]`.

**Important — loading detaches the array:** Calling this method makes the `JsonArray` its own independent JSON document. If the object previously referenced an array nested inside another JSON document, that relationship is discarded. For this reason, call `Load`/`LoadSb` on a new `JsonArray` instance.

Returns 1 for success, 0 for failure.

### JsonArray.ObjectAt

`Chilkat 11.7.0 · asp · JsonArray · ObjectAt · method · since 9.5.0.56`

```visual-basic
set jsonObject = jsonArray.ObjectAt(index)  ' ChilkatJsonObject
```

Returns the JSON object stored at zero-based position `index`.

**Reference, not copy:** The returned `JsonObject` refers to the existing object in the same JSON document. Changes made through the returned object modify that nested object.

**Type requirement:** The value at `index` must be an object. Use `TypeAt` when the value type is not already known.

Returns `Nothing` on failure

### JsonArray.ObjectAt2

`Chilkat 11.7.0 · asp · JsonArray · ObjectAt2 · method · since 11.0.0`

```visual-basic
success = jsonArray.ObjectAt2(index, jsonObj)  ' Long (1/0)
```

Updates `jsonObj` so that it references the JSON object stored at zero-based position `index`.

**Reference, not copy:** Changes made through `jsonObj` modify the existing object in the same JSON document.

Returns 1 for success, 0 for failure.

### JsonArray.SetBoolAt

`Chilkat 11.7.0 · asp · JsonArray · SetBoolAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.SetBoolAt(index, value)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with the specified JSON boolean value. The array length and the positions of other elements are unchanged.

Returns 1 for success, 0 for failure.

### JsonArray.SetIntAt

`Chilkat 11.7.0 · asp · JsonArray · SetIntAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.SetIntAt(index, value)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with the specified JSON integer value. The array length and the positions of other elements are unchanged.

Returns 1 for success, 0 for failure.

### JsonArray.SetNullAt

`Chilkat 11.7.0 · asp · JsonArray · SetNullAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.SetNullAt(index)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with the JSON value `null`. The array length and the positions of other elements are unchanged.

Returns 1 for success, 0 for failure.

### JsonArray.SetNumberAt

`Chilkat 11.7.0 · asp · JsonArray · SetNumberAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.SetNumberAt(index, value)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with a JSON number. The `value` argument supplies the exact JSON numeric text to store.

**Exact numeric text:** Use this method when lexical form or precision matters. The supplied text must be valid JSON number syntax; JSON does not permit `NaN` or infinity.

Returns 1 for success, 0 for failure.

### JsonArray.SetStringAt

`Chilkat 11.7.0 · asp · JsonArray · SetStringAt · method · since 9.5.0.56`

```visual-basic
success = jsonArray.SetStringAt(index, value)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with the specified JSON string value. The array length and the positions of other elements are unchanged.

Returns 1 for success, 0 for failure.

### JsonArray.SetUIntAt

`Chilkat 11.7.0 · asp · JsonArray · SetUIntAt · method · since 9.5.0.96`

```visual-basic
success = jsonArray.SetUIntAt(index, value)  ' Long (1/0)
```

Replaces the value at zero-based position `index` with the specified JSON unsigned integer value. The array length and the positions of other elements are unchanged.

Returns 1 for success, 0 for failure.

### JsonArray.StringAt

`Chilkat 11.7.0 · asp · JsonArray · StringAt · method · since 9.5.0.56`

```visual-basic
str = jsonArray.StringAt(index)  ' String
```

Returns the string value stored at zero-based position `index`.

**Type-aware access:** Use `TypeAt` when the JSON type at `index` is not already known.

Returns `Nothing` on failure

### JsonArray.Swap

`Chilkat 11.7.0 · asp · JsonArray · Swap · method · since 9.5.0.76`

```visual-basic
success = jsonArray.Swap(index1, index2)  ' Long (1/0)
```

Exchanges the values at zero-based positions `index1` and `index2`. The array length does not change.

Returns 1 for success, 0 for failure.

### JsonArray.TypeAt

`Chilkat 11.7.0 · asp · JsonArray · TypeAt · method · since 9.5.0.58`

```visual-basic
n = jsonArray.TypeAt(index)  ' Long
```

Returns an integer identifying the JSON type of the value at zero-based position `index`. Returns `-1` if no value exists at that index.

|  |  |
| --- | --- |
| `1` | string |
| `2` | number |
| `3` | object |
| `4` | array |
| `5` | boolean |
| `6` | null |

**Why use TypeAt:** JSON arrays may contain mixed types. Checking the type first avoids choosing a type-specific accessor such as `ObjectAt`, `ArrayAt`, or `IntAt` for the wrong kind of value.

### JsonArray.UIntAt

`Chilkat 11.7.0 · asp · JsonArray · UIntAt · method · since 9.5.0.96`

```visual-basic
n = jsonArray.UIntAt(index)  ' Long
```

Returns the unsigned integer value stored at zero-based position `index`.

**Type-aware access:** Use `TypeAt` when the JSON type at `index` is not already known.

## Related classes

[`CkDateTime`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/asp/classes/CkDateTime.md), [`DtObj`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/asp/classes/DtObj.md), [`JsonObject`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/asp/classes/JsonObject.md), [`StringBuilder`](https://www.chilkatsoft.com/ai-docs/v/11.7.0/asp/classes/StringBuilder.md)

