Michiyo: Clean up Markdown artifacts from DokuWiki migration

2026-08-24T20:26:39Z

Clean up Markdown artifacts from DokuWiki migration

← Older revision		Revision as of 20:26, 24 August 2026
Line 3:		Line 3:
	The component API is used to access and interact with components available to a computer. Also see [[Component/component access\|the page on component interaction]].		The component API is used to access and interact with components available to a computer. Also see [[Component/component access\|the page on component interaction]].

	* `component.doc(address:string, method:string): string`		* <code>component.doc(address:string, method:string): string</code>

	<pre>Returns the documentation string for the method with the specified name of the component with the specified address, if any. Note that you can also get this string by using `tostring` on a method in a proxy, for example `tostring(component.screen.isOn)`.		<pre>Returns the documentation string for the method with the specified name of the component with the specified address, if any. Note that you can also get this string by using tostring on a method in a proxy, for example tostring(component.screen.isOn).
	</pre>		</pre>
	* `component.invoke(address:string, method:string[, ...]): ...`		* <code>component.invoke(address:string, method:string[, ...]): ...</code>

	<pre>Calls the method with the specified name on the component with the specified address, passing the remaining arguments as arguments to that method. Returns the result of the method call, i.e. the values returned by the method. Depending on the called method's implementation this may throw.		<pre>Calls the method with the specified name on the component with the specified address, passing the remaining arguments as arguments to that method. Returns the result of the method call, i.e. the values returned by the method. Depending on the called method's implementation this may throw.
	</pre>		</pre>
	* `component.list([filter:string[, exact:boolean]]):function`		* <code>component.list([filter:string[, exact:boolean]]):function</code>

	<pre>Returns a table with all components currently attached to the computer, with address as a key and component type as a value. It also provides iterator syntax via `__call`, so you can use it like so: `for address, componentType in component.list() do ... end`		<pre>Returns a table with all components currently attached to the computer, with address as a key and component type as a value. It also provides iterator syntax via __call, so you can use it like so: for address, componentType in component.list() do ... end
	If `filter` is set this will only return components that contain the filter string (this is ''not'' a pattern/regular expression). For example, `component.list("red")` will return `redstone` components.		If filter is set this will only return components that contain the filter string (this is ''not'' a pattern/regular expression). For example, component.list("red") will return redstone components.
	If `true` is passed as a second parameter, exact matching is enforced, e.g. `red` will ''not'' match `redstone`.		If true is passed as a second parameter, exact matching is enforced, e.g. red will ''not'' match redstone.
	</pre>		</pre>
	* `component.methods(address:string):table`		* <code>component.methods(address:string):table</code>

	<pre>Returns a table with the names of all methods provided by the component with the specified address. The names are the keys in the table, the values indicate whether the method is called directly or not.		<pre>Returns a table with the names of all methods provided by the component with the specified address. The names are the keys in the table, the values indicate whether the method is called directly or not.
	</pre>		</pre>
	* `component.proxy(address:string):table`		* <code>component.proxy(address:string):table</code>

	<pre>Gets a 'proxy' object for a component that provides all methods the component provides as fields, so they can be called more directly (instead of via `invoke`). This is what's used to generate 'primaries' of the individual component types, i.e. what you get via `component.blah`.		<pre>Gets a 'proxy' object for a component that provides all methods the component provides as fields, so they can be called more directly (instead of via invoke). This is what's used to generate 'primaries' of the individual component types, i.e. what you get via component.blah.
	For example, you can use it like so: `component.proxy(component.list("redstone")()).getInput(sides.north)`, which gets you a proxy for the first `redstone` component returned by the `component.list` iterator, and then calls `getInput` on it.		For example, you can use it like so: component.proxy(component.list("redstone")()).getInput(sides.north), which gets you a proxy for the first redstone component returned by the component.list iterator, and then calls getInput on it.
	Note that proxies will always have at least two fields, `type` with the component's type name, and `address` with the component's address.		Note that proxies will always have at least two fields, type with the component's type name, and address with the component's address.
	</pre>		</pre>
	* `component.type(address:string):string`		* <code>component.type(address:string):string</code>

	<pre>Get the component type of the component with the specified address.		<pre>Get the component type of the component with the specified address.
	</pre>		</pre>
	* `component.slot(address:string):string`		* <code>component.slot(address:string):string</code>

	<pre>Return slot number which the component is installed into. Returns -1 if it doesn't otherwise make sense.		<pre>Return slot number which the component is installed into. Returns -1 if it doesn't otherwise make sense.
	</pre>		</pre>
	* `component.fields(address:string):string`		* <code>component.fields(address:string):string</code>

	<pre>Undocumented		<pre>Undocumented
	</pre>		</pre>
	* `component.get(address: string[, componentType: string]): string \| (nil, string)`		* <code>component.get(address: string[, componentType: string]): string \| (nil, string)</code>

	<pre>Tries to resolve an abbreviated address to a full address. Returns the full address on success, or `nil` and an error message otherwise. Optionally filters by component type.		<pre>Tries to resolve an abbreviated address to a full address. Returns the full address on success, or nil and an error message otherwise. Optionally filters by component type.
	</pre>		</pre>
	* `component.isAvailable(componentType: string): boolean`		* <code>component.isAvailable(componentType: string): boolean</code>

	<pre>Checks if there is a primary component of the specified component type.		<pre>Checks if there is a primary component of the specified component type.
	</pre>		</pre>
	* `component.getPrimary(componentType: string): table`		* <code>component.getPrimary(componentType: string): table</code>

	<pre>Gets the proxy for the primary component of the specified type. Throws an error if there is no primary component of the specified type.		<pre>Gets the proxy for the primary component of the specified type. Throws an error if there is no primary component of the specified type.
	</pre>		</pre>
	* `component.setPrimary(componentType: string, address: string)`		* <code>component.setPrimary(componentType: string, address: string)</code>

	<pre>Sets a new primary component for the specified component type. The address may be abbreviated, but must be valid if it is not `nil`. Triggers the `component_unavailable` and `component_available` signals if set to `nil` or a new value, respectively.		<pre>Sets a new primary component for the specified component type. The address may be abbreviated, but must be valid if it is not nil. Triggers the component_unavailable and component_available signals if set to nil or a new value, respectively.

	</pre>		</pre>
	Note that the component API has a metatable that allows the following syntax:		Note that the component API has a metatable that allows the following syntax:

	~~```~~lua local component = require("component") local rs0 = component.getPrimary("redstone") local rs1 = component.redstone -- syntactic sugar print(rs0 == rs1) -- true ~~```~~		<syntaxhighlight lang="lua">
			local component = require("component") local rs0 = component.getPrimary("redstone") local rs1 = component.redstone -- syntactic sugar print(rs0 == rs1) -- true
			</syntaxhighlight>

	== Contents ==		== Contents ==

	{{:API/contents}}		{{:API/contents}}

imported>OCDoc Import: Imported from legacy OpenComputers documentation at ocdoc.cil.li

2026-08-24T08:08:27Z

Imported from legacy OpenComputers documentation at ocdoc.cil.li

New page

= Component API =

The component API is used to access and interact with components available to a computer. Also see [[Component/component access|the page on component interaction]].

* `component.doc(address:string, method:string): string`

<pre>Returns the documentation string for the method with the specified name of the component with the specified address, if any. Note that you can also get this string by using `tostring` on a method in a proxy, for example `tostring(component.screen.isOn)`.
</pre>
* `component.invoke(address:string, method:string[, ...]): ...`

<pre>Calls the method with the specified name on the component with the specified address, passing the remaining arguments as arguments to that method. Returns the result of the method call, i.e. the values returned by the method. Depending on the called method's implementation this may throw.
</pre>
* `component.list([filter:string[, exact:boolean]]):function`

<pre>Returns a table with all components currently attached to the computer, with address as a key and component type as a value. It also provides iterator syntax via `__call`, so you can use it like so: `for address, componentType in component.list() do ... end`
If `filter` is set this will only return components that contain the filter string (this is ''not'' a pattern/regular expression). For example, `component.list("red")` will return `redstone` components.
If `true` is passed as a second parameter, exact matching is enforced, e.g. `red` will ''not'' match `redstone`.
</pre>
* `component.methods(address:string):table`

<pre>Returns a table with the names of all methods provided by the component with the specified address. The names are the keys in the table, the values indicate whether the method is called directly or not.
</pre>
* `component.proxy(address:string):table`

<pre>Gets a 'proxy' object for a component that provides all methods the component provides as fields, so they can be called more directly (instead of via `invoke`). This is what's used to generate 'primaries' of the individual component types, i.e. what you get via `component.blah`.
For example, you can use it like so: `component.proxy(component.list("redstone")()).getInput(sides.north)`, which gets you a proxy for the first `redstone` component returned by the `component.list` iterator, and then calls `getInput` on it.
Note that proxies will always have at least two fields, `type` with the component's type name, and `address` with the component's address.
</pre>
* `component.type(address:string):string`

<pre>Get the component type of the component with the specified address.
</pre>
* `component.slot(address:string):string`

<pre>Return slot number which the component is installed into. Returns -1 if it doesn't otherwise make sense.
</pre>
* `component.fields(address:string):string`

<pre>Undocumented
</pre>
* `component.get(address: string[, componentType: string]): string | (nil, string)`

<pre>Tries to resolve an abbreviated address to a full address. Returns the full address on success, or `nil` and an error message otherwise. Optionally filters by component type.
</pre>
* `component.isAvailable(componentType: string): boolean`

<pre>Checks if there is a primary component of the specified component type.
</pre>
* `component.getPrimary(componentType: string): table`

<pre>Gets the proxy for the primary component of the specified type. Throws an error if there is no primary component of the specified type.
</pre>
* `component.setPrimary(componentType: string, address: string)`

<pre>Sets a new primary component for the specified component type. The address may be abbreviated, but must be valid if it is not `nil`. Triggers the `component_unavailable` and `component_available` signals if set to `nil` or a new value, respectively.

</pre>
Note that the component API has a metatable that allows the following syntax:

```lua local component = require("component") local rs0 = component.getPrimary("redstone") local rs1 = component.redstone -- syntactic sugar print(rs0 == rs1) -- true ```

== Contents ==

{{:API/contents}}

API/component - Revision history

Michiyo: Clean up Markdown artifacts from DokuWiki migration

imported>OCDoc Import: Imported from legacy OpenComputers documentation at ocdoc.cil.li