# Item

The **Item** object represents a file or folder displayed in a tab. You can obtain a collection of **Item** objects from the various methods of the [**Tab**](tab) object. A collection of **Item** objects is also used with the [**Command**](command) object to specify the files or folders a command should operate on. Using the [**FSUtil**](fsutil)**.ReadDir** method to enumerate the contents of a folder also returns an **Item** object. You can create an **Item** from a file path using the [**FSUtil**](fsutil)**.GetItem** method.

| Property Name      | Return Type                                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| ------------------ | ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| _\<default value>_ | _string_                                                | Returns the full pathname of the item (i.e. path plus filename).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| access             | _date_                                                  | Returns the "last accessed" date, in local time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| access\_utc        | _date_                                                  | Returns the "last accessed" date, in UTC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| attr               | _int_                                                   | <p>Returns the item attributes. This value is a series of flags that are logically OR'd together. The attributes supported by Opus are:</p><table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td>1</td><td>read only</td></tr><tr><td>2</td><td>hidden</td></tr><tr><td>4</td><td>system</td></tr><tr><td>32</td><td>archive</td></tr><tr><td>1024</td><td>reparse point (junctions, etc.)</td></tr><tr><td>2048</td><td>compressed</td></tr><tr><td>4096</td><td>offline storage</td></tr><tr><td>8192</td><td>not content-indexed</td></tr><tr><td>16384</td><td>encrypted</td></tr><tr><td>524288</td><td>pinned</td></tr></tbody></table><p>Using the <strong>fileattr</strong> property, which returns a <a href="fileattr"><strong>FileAttr</strong></a> object, may be easier than dealing with the raw attribute flags.</p> |
|                    |                                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 1                  | read only                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 2                  | hidden                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 4                  | system                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 32                 | archive                                                 |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 1024               | reparse point (junctions, etc.)                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 2048               | compressed                                              |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 4096               | offline storage                                         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 8192               | not content-indexed                                     |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 16384              | encrypted                                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| 524288             | pinned                                                  |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| attr\_text         | _string_                                                | Returns the item attributes as a string, as displayed in the file display.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| checked            | _bool_                                                  | Returns **True** if the item was checked (in [checkbox mode](../../../basic_concepts/selecting_files/selecting_with_the_mouse_and_keyboard/checkbox_mode)), or **False** otherwise.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| create             | _date_                                                  | Returns the "creation" date, in local time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| create\_utc        | _date_                                                  | Returns the "creation" date, in UTC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| current            | _bool_                                                  | <p>For <strong>Item</strong> objects obtained from a <a href="viewer"><strong>Viewer</strong></a>, this property is <strong>True</strong> if the item represents the currently displayed image and <strong>False</strong> otherwise.</p><p>For <strong>Item</strong> objects obtained from a file display, the property indicates whether or not the item is the one with focus. The <strong>focus</strong> property is the more proper way to check this, but both work in case you forget which is which.</p>                                                                                                                                                                                                                                                                                                                               |
| display\_name      | _string_                                                | Returns the display name of the item. Only a few items have a display name that is different to their actual name - some examples are certain system folders (like _C:\Users_ which might have a translated display name in non-English locales).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ext                | _string_                                                | Returns the filename extension.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ext\_m             | _string_                                                | Returns the filename extension, taking multi-part extensions into account. For example, a file called "file.part1.rar" might return ".rar" for **ext** but ".part1.rar" for **ext\_m**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| failed             | _bool_                                                  | Returns **True** if the item failed when used by a command. This is only meaningful in conjunction with the [**Command**](command)**.files** collection - once the command has returned, this property will indicate success or failure on a per-file basis.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| fileattr           | _object:_[**FileAttr**](fileattr)                       | Returns a [**FileAttr**](fileattr) object that represents the item's attributes.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| filegroup          | _object:_[**FileGroup**](filegroup)                     | <p>If the file display this item came from is grouped by a particular column, this property returns a <a href="filegroup"><strong>FileGroup</strong></a> object representing the group the item is in. If the item has no group this will return an empty string.</p><p>This property is about grouping the file display by one of its columns. If you're looking for <em>file type groups</em>, see the <strong>groups</strong> and <strong>groupsobject</strong> properties, just below.</p>                                                                                                                                                                                                                                                                                                                                                |
| focus              | _bool_                                                  | <p>For <strong>Item</strong> objects obtained from a file display, this property is <strong>True</strong> if the object represents the item with focus, and <strong>False</strong> otherwise. Only one item can have focus at a time. The item with focus is typically shown with an outline around it, and is usually the last item which was clicked on, or which was moved to with the keyboard. The item with focus is often also one of the selected items, but not always; selection and focus are two separate things.</p><p>For <strong>Item</strong> objects obtained from a <a href="viewer"><strong>Viewer</strong></a>, the property indicates if the file is the one currently shown in the viewer. The <strong>current</strong> property is the more proper way to test this, but <strong>focus</strong> also works.</p>        |
| got\_size          | _bool_                                                  | Returns **True** for folder items if their size has been calculated by, for example, the [**GetSizes**](../../command_reference/internal_commands/getsizes) command. If **False**, the **size** property will be unreliable for folders.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| groups             | [**Vector**](vector):[**FiletypeGroup**](filetypegroup) | <p>Returns a <a href="vector"><strong>Vector</strong></a> of <a href="filetypegroup"><strong>FiletypeGroup</strong></a> objects representing any and all file type groups that this file is a member of.</p><p>If you only want to check membership of a particular file type group, see the <strong>InGroup</strong> method in the section below.</p><p>If you're looking for information on how the file display is grouping this file based on one of the displayed columns, see the <strong>filegroup</strong> property, just above.</p>                                                                                                                                                                                                                                                                                                  |
| groupsobject       | _object:_[**FiletypeGroups**](filetypegroups)           | Similar to the groups property, except a [**FiletypeGroups**](filetypegroups) object is returned instead of a [**Vector**](vector).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| highlighted        | _object:_[**HighlightedColumns**](highlightedcolumns)   | <p>Returns a <a href="highlightedcolumns"><strong>HighlightedColumns</strong></a> object that lets you enumerate any <a href="../../../basic_concepts/selecting_files/selecting_cells">selected cells</a> belonging to this item.</p><p>This only applies if the item was retrieved from a <a href="tab"><strong>Tab</strong></a>. Normally you would use this in a script run from the <strong>Copy Highlighted Cells</strong> context menu.</p>                                                                                                                                                                                                                                                                                                                                                                                             |
| id                 | _int_                                                   | This is a unique ID for the item; it is used internally by Opus.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| is\_dir            | _bool_                                                  | Returns **True** if the item represents a folder, and **False** for a file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| is\_junction       | _bool_                                                  | Returns **True** if the item is a junction to another folder.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| is\_reparse        | _bool_                                                  | Returns **True** if the item is a reparse point.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| is\_symlink        | _bool_                                                  | Returns **True** if the item is a symbolic link.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| metadata           | _object:_[**Metadata**](metadata)                       | Returns a [**Metadata**](metadata) object that provides access to the item's metadata.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| modify             | _date_                                                  | Returns the "last modified" date, in local time.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| modify\_utc        | _date_                                                  | Returns the "last modified" date, in UTC.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| name               | _string_                                                | Returns the name of the item.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| name\_stem         | _string_                                                | Returns the filename "stem" of the item. This is the name of the item with the filename extension removed. It will be the same as the **name** for folders.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| name\_stem\_m      | _string_                                                | Returns the filename "stem" of the item, taking multi-part extensions into account. For example, a file called "file.part1.rar" might return "file.part1" for **name\_stem** but "file" for **name\_stem\_m**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| nested             | _bool_                                                  | Returns **True** if the item was in an expanded sub-folder, **False** if it was in the root of the folder.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| path               | _object:_[**Path**](path)                               | Returns the path of the item's parent folder. This does not include the name of the item itself, which can be obtained via the **name** property.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| realpath           | _object:_[**Path**](path)                               | Returns the "real" path of the item. For items located in [virtual folders](../../../preferences/preferences_categories/folders/virtual_folders)like [Libraries](../../../basic_concepts/virtual_file_system/libraries) or [Collections](../../../basic_concepts/virtual_file_system/file_collections), this lets you access the item's underlying path in the real file system. The **realpath** property includes the full path to the item, including its own name.                                                                                                                                                                                                                                                                                                                                                                        |
| selected           | _bool_                                                  | Returns **True** if the item was selected, or **False** otherwise.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| shortpath          | _object:_[**Path**](path)                               | Returns the short path of the item, if it has one. Note that short paths are disabled by default in Windows 10.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| size               | _object:_[**FileSize**](filesize)                       | Returns the size of the item as a [**FileSize**](filesize) object.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |

| Method Name | **Arguments**                                                                                                              | Return Type                   | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| ----------- | -------------------------------------------------------------------------------------------------------------------------- | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| InGroup     | \<string:group>                                                                                                            | _bool_                        | <p>Tests the file for membership of the specified file type group.</p><p>Each file type group has two names: An internal name which is always the same in all languages, and a display name which may be translated differently for each language. The display name is what you see in the File Types editor. Groups that come pre-defined when you install Opus have internal names like <em>"Archives"</em> and <em>"Music"</em> (which are also their English display names). User-defined groups have internal names which are unique, automatically generated GUID strings like <em>"{C4B716ED-2A9C-43C6-B325-7DADDEEFADA9}"</em>.</p><p>The <em>group</em> argument should be the name of the group you wish to test against, e.g. <em>"Music"</em>.</p><p>By default, both the internal name and the display name are checked, and a match on either will return true. Prefix the <em>group</em> argument with <em>"name:"</em> to restrict the search to internal names, or with <em>"disp:"</em> to restrict the search to display names.</p><p>To get a list of all file type groups which the file matches, use the <strong>groups</strong> property instead (see the section above).</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Labels      | <p>&#x3C;string:category><br>&#x3C;string:flags></p>                                                                       | [**Vector**](vector):_string_ | <p>This method returns a <a href="vector"><strong>Vector</strong></a> of strings representing any <a href="../../../file_operations/labels">labels</a> that have been assigned to the item.</p><p>Both arguments are optional. The first is a <a href="../../wildcard_reference/pattern_matching_syntax">wildcard pattern</a> that lets you filter the returned labels based on their category. For example, pass <em>"Status"</em> to only retrieve a list of status icons assigned to a file.</p><p>The second optional argument contains flags keywords that control how the labels are returned. The only defined flag is <em>"explicit"</em> - if specified, wildcard and label filters will not be considered - only explicitly assigned labels will be returned. Note that if you want to provide the second argument but don't want to filter by category you should pass <em>"*"</em> for the first argument to match all categories.</p><p>If explicit labels aren't requested, any global wildcard/filter labels will be returned, along with any per-folder labels configured for the item's folder. Per-folder <em>content type</em> and <em>folder type</em> labels, however, are not currently returned by this function.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| MatchFilter | <p>&#x3C;object:filter><br>or &#x3C;string:filter></p>                                                                     | _bool_                        | <p>Returns <strong>True</strong> if the item matches the specified filter. The <em>filter</em> argument must be a <a href="filter"><strong>Filter</strong></a> object created by the <a href="dopusfactory"><strong>DOpusFactory</strong></a><strong>.NewFilter</strong> method.</p><p>You can also pass a <a href="../../textual_filters">textual filter</a> in string form, to parse the filter and compare the item in one operation, although if you're comparing multiple items it would be much more efficient to create the <strong>Filter</strong> first.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Open        | <p>&#x3C;string:mode><br>&#x3C;object:window></p>                                                                          | _object:_[**File**](file)     | <p>Opens this file and returns a <a href="file"><strong>File</strong></a> object that lets you access its contents as binary data.</p><p>By default the file will be opened in <em>read mode</em> - specify <em>"w"</em> for the optional <em>mode</em> parameter to open the file in <em>write mode.</em> Note that you cannot both read and write with the same <strong>File</strong> object.</p><p>When opening in write mode, you can also specify optional flags that control how the file is opened:</p><table><thead><tr><th></th><th></th></tr></thead><tbody><tr><td>wc</td><td>create a new file, only if it doesn't already exist.</td></tr><tr><td>wa</td><td>create a new file, always. If the file already exists it will be overwritten. (This is the default.)</td></tr><tr><td>we</td><td>open existing file. The file will not be created if it doesn't already exist.</td></tr><tr><td>wo</td><td>open existing file. If the file doesn't exist it will be created.</td></tr><tr><td>wt</td><td>truncate existing file. If the file exists it will be truncated. The file will not be created if it doesn't already exist.</td></tr><tr><td>d</td><td>delete-on-close.</td></tr></tbody></table><p>When using write mode, you may add <em>f</em> (force) to any of the above mode strings to tell Opus to clear the read-only file attribute if it blocks modifying an existing file; otherwise, attempting to open a read-only file for writing will fail. For example, <em>"wof"</em> is like <em>"wo"</em> mode but also clears the read-only attribute.</p><p>If you only want to make changes to the file's attributes without modifying its data you can also specify <em>"m"</em> to open it in <em>modify mode</em>.</p><p>The optional <em>window</em> parameter lets you associate the <strong>File</strong> object with a <a href="tab"><strong>Tab</strong></a> or a <a href="lister"><strong>Lister</strong></a>, which will be used if Opus needs to display any dialogs (e.g. a UAC elevation dialog). You may also specify the string "NoElevate" to prevent UAC elevation entirely, or "ElevateNoAsk" to prevent UAC prompts while still gaining elevation if something else has already performed it.</p><p>A <strong>File</strong> object is always returned, even if the file could not be opened. Check <strong>File.error</strong> on the returned object immediately after creating it to see if opening the file succeeded. Even if the file was not be opened, some of the object's methods may still work. For example, if a file doesn't exist then you can't open it or set its attributes, but permissions on an existing file may allow you to set its attributes while blocking you from modifying it or vice versa.</p> |
|             |                                                                                                                            |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| wc          | create a new file, only if it doesn't already exist.                                                                       |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| wa          | create a new file, always. If the file already exists it will be overwritten. (This is the default.)                       |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| we          | open existing file. The file will not be created if it doesn't already exist.                                              |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| wo          | open existing file. If the file doesn't exist it will be created.                                                          |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| wt          | truncate existing file. If the file exists it will be truncated. The file will not be created if it doesn't already exist. |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| d           | delete-on-close.                                                                                                           |                               |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| ShellProp   | <p>&#x3C;string:property><br>&#x3C;string:type></p>                                                                        | _variant_                     | <p>Returns the value of the specified shell property for the item. The property argument can be the property's PKEY or its name.</p><p>If you provide a name then the optional second argument lets you control how the properties are looked up by name. If the value of <em>type</em> is "R" then the first property whose raw name matches the supplied name will be used. If the value is "D" then the first property whose display name matches the supplied name will be used. If <em>type</em> is omitted then both raw and display names can match.</p><p>Note that if a shell property is returned by the system as a SAFEARRAY type, it will be converted automatically to a <a href="vector"><strong>Vector</strong></a> object.</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Update      | _none_                                                                                                                     | _none_                        | Updates the **Item** object from the file on disk. You might use this if you had run a command to change an item's timestamp or attributes, and wanted to retrieve the new information.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
