Nette Documentation Preview

syntax
HTTP request
************

.[perex]
Nette zapouzdřuje HTTP požadavek do objektů se srozumitelným API a zároveň poskytuje sanitizační filtr.

HTTP požadavek představuje objekt [api:Nette\Http\Request], ke kterému se dostanete tak, že si jej necháte předat pomocí [dependency injection |dependency-injection:passing-dependencies]. V presenterech stačí jen zavolat `$httpRequest = $this->getHttpRequest()`.

Co je důležité, tak že Nette když [vytváří|#RequestFactory] tento objekt, všechny vstupní parametry GET, POST, COOKIE a také URL pročistí od kontrolních znaků a neplatných UTF-8 sekvencí. Takže s daty pak můžete bezpečně dále pracovat. Očištěná data se následně používají v presenterech a formulářích.

→ [Instalace a požadavky |@home#Instalace]


Nette\Http\Request
==================

Tento objekt je immutable (neměnný). Nemá žádné settery, má jen jeden tzv. wither `withUrl()`, který objekt nemění, ale vrací novou instanci se změněnou hodnotou.


withUrl(Nette\Http\UrlScript $url): Nette\Http\Request .[method]
----------------------------------------------------------------
Vrací klon s jinou URL.


getUrl(): Nette\Http\UrlScript .[method]
----------------------------------------
Vrací URL požadavku jako objekt [UrlScript|urls#UrlScript].

```php
$url = $httpRequest->getUrl();
echo $url; // https://doc.nette.org/cs/?action=edit
echo $url->getHost(); // nette.org
```

Prohlížeče neodesílají na server fragment, takže `$url->getFragment()` bude vracet prázdný řetězec.


getQuery(string $key=null): string|array|null .[method]
-------------------------------------------------------
Vrací parametry GET požadavku.

```php
$all = $httpRequest->getQuery(); // vrací pole všech parametrů z URL
$id = $httpRequest->getQuery('id'); // vrací GET parametr 'id' (nebo null)
```


getPost(string $key=null): string|array|null .[method]
------------------------------------------------------
Vrací parametry POST požadavku.

```php
$all = $httpRequest->getPost(); // vrací pole všech parametrů z POST
$id = $httpRequest->getPost('id'); // vrací POST parametr 'id' (nebo null)
```


getFile(string|string[] $key): Nette\Http\FileUpload|array|null .[method]
-------------------------------------------------------------------------
Vrací [upload|#Uploadované soubory] jako objekt [api:Nette\Http\FileUpload]:

```php
$file = $httpRequest->getFile('avatar');
if ($file->hasFile()) { // byl nějaký soubor nahraný?
	$file->getUntrustedName(); // jméno souboru odeslané uživatelem
	$file->getSanitizedName(); // jméno bez nebezpečných znaků
}
```

Pro přístup do zanořené struktury uveďte pole klíčů. (Od verze 3.1)

```php
//<input type="file" name="my-form[details][avatar]" multiple>
$file = $request->getFile(['my-form', 'details', 'avatar']);
```

Protože nelze důvěřovat datům zvenčí a tedy ani spoléhat na podobu struktury souborů, je bezpečnější tento způsob než třeba `$request->getFiles()['my-form']['details']['avatar']`, který může selhat.


getFiles(): array .[method]
---------------------------
Vrátí strom [všech uploadů|#Uploadované soubory] v normalizované struktuře, jejíž listy jsou objekty [api:Nette\Http\FileUpload]:

```php
$files = $httpRequest->getFiles();
```


getCookie(string $key): string|array|null .[method]
---------------------------------------------------
Vrací cookie nebo `null`, když neexistuje.

```php
$sessId = $httpRequest->getCookie('sess_id');
```


getCookies(): array .[method]
-----------------------------
Vrací všechny cookies.

```php
$cookies = $httpRequest->getCookies();
```


getMethod(): string .[method]
-----------------------------
Vrací HTTP metodu, se kterou byl udělán požadavek.

```php
$httpRequest->getMethod(); // GET, POST, HEAD, PUT
```


isMethod(string $method): bool .[method]
----------------------------------------
Testuje HTTP metodu, se kterou byl udělán požadavek. Parametr je case-insensitive.

```php
if ($httpRequest->isMethod('GET')) // ...
```


getHeader(string $header): ?string .[method]
--------------------------------------------
Vrací HTTP hlavičku nebo `null`, pokud neexistuje. Parametr je case-insensitive.

```php
$userAgent = $httpRequest->getHeader('User-Agent');
```


getHeaders(): array .[method]
-----------------------------
Vrací všechny HTTP hlavičky jako asociativní pole.

```php
$headers = $httpRequest->getHeaders();
echo $headers['Content-Type'];
```


isSecured(): bool .[method]
---------------------------
Je spojení šifrované (HTTPS)? Pro správnou funkčnost může být potřeba [nastavit proxy|configuration#HTTP proxy].


isSameSite(): bool .[method]
----------------------------
Přichází požadavek ze stejné (sub)domény a je iniciován kliknutím na odkaz? Nette k detekci používá cookie `_nss` (dříve `nette-samesite`).


isAjax(): bool .[method]
------------------------
Jde o AJAXový požadavek?


getRemoteAddress(): ?string .[method]
-------------------------------------
Vrací IP adresu uživatele. Pro správnou funkčnost může být potřeba [nastavit proxy|configuration#HTTP proxy].


getRemoteHost(): ?string .[method deprecated]
---------------------------------------------
Vrací DNS překlad IP adresy uživatele. Pro správnou funkčnost může být potřeba [nastavit proxy|configuration#HTTP proxy].


getBasicCredentials(): ?string .[method]{data-version:v3.2}
-----------------------------------------------------------
Vrací ověřovací údaje pro [Basic HTTP authentication |https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication].

```php
[$user, $password] = $httpRequest->getBasicCredentials();
```


getRawBody(): ?string .[method]
-------------------------------
Vrací tělo HTTP požadavku.

```php
$body = $httpRequest->getRawBody();
```


detectLanguage(array $langs): ?string .[method]
-----------------------------------------------
Detekuje jazyk. Jako parametr `$lang` předáme pole s jazyky, které aplikace podporuje, a ona vrátí ten, který by viděl návštěvníkův prohlížeč nejraději. Nejsou to žádná kouzla, jen se využívá hlavičky `Accept-Language`. Pokud nedojde k žádné shodě, vrací `null`.

```php
// prohlížeč odesílá např. Accept-Language: cs,en-us;q=0.8,en;q=0.5,sl;q=0.3

$langs = ['hu', 'pl', 'en']; // jazyky podporované aplikací
echo $httpRequest->detectLanguage($langs); // en
```


RequestFactory
==============

Objekt aktuálního HTTP requestu vyrobí [api:Nette\Http\RequestFactory]. Pokud píšete aplikaci, která nepoužívá DI kontejner, vyrobíte request takto:

```php
$factory = new Nette\Http\RequestFactory;
$httpRequest = $factory->fromGlobals();
```

RequestFactory lze před zavoláním `fromGlobals()` konfigurovat. Můžeme vypnout sanitizaci vstupních parametrů od kontrolních znaků a neplatných UTF-8 sekvencí pomocí `$factory->setBinary()`. A také nastavit proxy server pomocí `$factory->setProxy(...)`, což je důležité pro správnou detekci IP adresy uživatele.

Pomocí tzv. filtrů lze URL vyčistit od znaků, které se do něj mohou dostat např. kvůli špatně implementovaným komentářovým systémům na různých cizích webech:

```php
// odstraníme mezery z cesty
$requestFactory->urlFilters['path']['%20'] = '';

// odstraníme tečku, čárku nebo pravou závorku z konce URI
$requestFactory->urlFilters['url']['[.,)]$'] = '';

// vyčistíme cestu od zdvojených lomítek (výchozí filtr)
$requestFactory->urlFilters['path']['/{2,}'] = '/';
```


Uploadované soubory
===================

Metoda `Nette\Http\Request::getFiles()` vrací pole všech uploadů v normalizované struktuře, jejíž listy jsou objekty [api:Nette\Http\FileUpload]. Ty zapouzdřují data odeslaná formulářovým prvkem `<input type=file>`.

Struktura reflektuje pojmenování prvků v HTML. V nejjednodušším případě to může být jediný pojmenovaný element formuláře odeslaný jako:

```latte
<input type="file" name="avatar">
```

V tomto případě `$request->getFiles()` vrací pole:

```php
[
	'avatar' => /* FileUpload instance */
]
```

Objekt `FileUpload` se vytvoří i v případě, že uživatel žádný soubor neodeslal nebo odeslání selhalo. Jestli byl soubor odeslán vrací metoda `hasFile()`:

```php
$request->getFile('avatar')->hasFile();
```

V případě názvu elementu používajícího notaci pro pole:

```latte
<input type="file" name="my-form[details][avatar]">
```

vypadá vrácený strom takto:

```php
[
	'my-form' => [
		'details' => [
			'avatar' => /* FileUpload instance */
		],
	],
]
```

Lze vytvořit i pole souborů:

```latte
<input type="file" name="my-form[details][avatars][]" multiple>
```

V takovém případě vypadá struktura takto:

```php
[
	'my-form' => [
		'details' => [
			'avatars' => [
				0 => /* FileUpload instance */,
				1 => /* FileUpload instance */,
				2 => /* FileUpload instance */,
			],
		],
	],
]
```

Přistoupit k indexu 1 vnořeného pole lze nejlépe takto:

```php
$file = $request->getFile(['my-form', 'details', 'avatars', 1]);
// ve verzi 3.0 použijte:
//$file = Nette\Utils\Arrays::get(
//  $request->getFiles(),
//  ['my-form', 'details', 'avatars', 1],
//  null
//);
if ($file instanceof FileUpload) {
	// ...
}
```

Protože nelze důvěřovat datům zvenčí a tedy ani spoléhat na podobu struktury souborů, je bezpečnější tento způsob než třeba `$request->getFiles()['my-form']['details']['avatars'][1]`, který může selhat.


Přehled metod `FileUpload` .{toc: FileUpload}
---------------------------------------------


hasFile(): bool .[method]
-------------------------
Vrací `true`, pokud uživatel nějaký soubor uploadoval.


isOk(): bool .[method]
----------------------
Vrací `true`, pokud soubor byl nahrán úspěšně.


getError(): int .[method]
-------------------------
Vrací kód chyby při uploadu souboru. Jde o jednu z konstant [UPLOAD_ERR_XXX|http://php.net/manual/en/features.file-upload.errors.php]. V případě, že upload proběhl v pořádku, vrací `UPLOAD_ERR_OK`.


move(string $dest) .[method]
----------------------------
Přesune nahraný soubor do nového umístění. Pokud cílový soubor již existuje, bude přepsán.

```php
$file->move('/path/to/files/name.ext');
```


getContents(): ?string .[method]
--------------------------------
Vrací obsah uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací `null`.


getContentType(): ?string .[method]
-----------------------------------
Detekuje MIME content type uploadovaného souboru na základě jeho signatury. V případě, že upload nebyl úspěšný nebo detekce se nezdařila, vrací `null`.

.[caution]
Vyžaduje PHP rozšíření `fileinfo`.


getUntrustedName(): string .[method]
------------------------------------
Vrací originální název souboru, jak jej odeslal prohlížeč. Dříve se metoda jmenovala `getName()`.

.[caution]
Nevěřte hodnotě vrácené touto metodou. Klient mohl odeslat škodlivý název souboru s úmyslem poškodit nebo hacknout vaši aplikaci.


getSanitizedName(): string .[method]
------------------------------------
Vrací sanitizovaný název souboru. Obsahuje pouze ASCII znaky `[a-zA-Z0-9.-]`.

Od verze 3.0.5: Pokud název takové znaky neobsahuje, vrátí `'unknown'`. Pokud je soubor obrázek ve formátu JPEG, PNG, GIF, nebo WebP, vrátí i správnou příponu.

.[caution]
Vyžaduje PHP rozšíření `fileinfo`.


getSuggestedExtension(): ?string .[method]{data-version:3.2.4}
--------------------------------------------------------------
Vrací vhodnou příponu souboru (bez tečky) odpovídající zjištěnému MIME typu.

.[caution]
Vyžaduje PHP rozšíření `fileinfo`.


getUntrustedFullPath(): string .[method]{data-version:v3.2}
-----------------------------------------------------------
Vrací originální cestu k souboru, jak ji odeslal prohlížeč při uploadu složky. Celá cesta je dostupná pouze v PHP 8.1 a vyšším. V předchozích verzích tato metoda vrací originální název souboru.

.[caution]
Nevěřte hodnotě vrácené touto metodou. Klient mohl odeslat škodlivý název souboru s úmyslem poškodit nebo hacknout vaši aplikaci.


getSize(): int .[method]
------------------------
Vrací velikost uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací `0`.


getTemporaryFile(): string .[method]
------------------------------------
Vrací cestu k dočasné lokaci uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací `''`.


isImage(): bool .[method]
-------------------------
Vrací `true`, pokud nahraný soubor je obrázek ve formátu JPEG, PNG, GIF, nebo WebP. Detekce probíhá na základě jeho signatury a neověřuje se integrita celého souboru. Zda není obrázek poškozený lze zjistit například pokusem o jeho [načtení|#toImage].

.[caution]
Vyžaduje PHP rozšíření `fileinfo`.


getImageSize(): ?array .[method]
--------------------------------
Vrací dvojici `[šířka, výška]` s rozměry uploadovaného obrázku. V případě, že upload nebyl úspěšný nebo nejde o platný obrázek, vrací `null`.


getImageFileExtension(): ?string .[method]{data-version:v3.0.5}
---------------------------------------------------------------
Vrátí příponu souboru obrázku na základě zjištěného typu obsahu (bez tečky).


toImage(): Nette\Utils\Image .[method]
--------------------------------------
Načte obrázek jak objekt [Image|utils:images]. V případě, že upload nebyl úspěšný nebo nejde o platný obrázek, vyhodí výjimku `Nette\Utils\ImageException`.

HTTP request

Nette zapouzdřuje HTTP požadavek do objektů se srozumitelným API a zároveň poskytuje sanitizační filtr.

HTTP požadavek představuje objekt Nette\Http\Request, ke kterému se dostanete tak, že si jej necháte předat pomocí dependency injection. V presenterech stačí jen zavolat $httpRequest = $this->getHttpRequest().

Co je důležité, tak že Nette když vytváří tento objekt, všechny vstupní parametry GET, POST, COOKIE a také URL pročistí od kontrolních znaků a neplatných UTF-8 sekvencí. Takže s daty pak můžete bezpečně dále pracovat. Očištěná data se následně používají v presenterech a formulářích.

Instalace a požadavky

Nette\Http\Request

Tento objekt je immutable (neměnný). Nemá žádné settery, má jen jeden tzv. wither withUrl(), který objekt nemění, ale vrací novou instanci se změněnou hodnotou.

withUrl(Nette\Http\UrlScript $url): Nette\Http\Request

Vrací klon s jinou URL.

getUrl(): Nette\Http\UrlScript

Vrací URL požadavku jako objekt UrlScript.

$url = $httpRequest->getUrl();
echo $url; // https://doc.nette.org/cs/?action=edit
echo $url->getHost(); // nette.org

Prohlížeče neodesílají na server fragment, takže $url->getFragment() bude vracet prázdný řetězec.

getQuery(string $key=null): string|array|null

Vrací parametry GET požadavku.

$all = $httpRequest->getQuery(); // vrací pole všech parametrů z URL
$id = $httpRequest->getQuery('id'); // vrací GET parametr 'id' (nebo null)

getPost(string $key=null): string|array|null

Vrací parametry POST požadavku.

$all = $httpRequest->getPost(); // vrací pole všech parametrů z POST
$id = $httpRequest->getPost('id'); // vrací POST parametr 'id' (nebo null)

getFile(string|string[] $key): Nette\Http\FileUpload|array|null

Vrací upload jako objekt Nette\Http\FileUpload:

$file = $httpRequest->getFile('avatar');
if ($file->hasFile()) { // byl nějaký soubor nahraný?
	$file->getUntrustedName(); // jméno souboru odeslané uživatelem
	$file->getSanitizedName(); // jméno bez nebezpečných znaků
}

Pro přístup do zanořené struktury uveďte pole klíčů. (Od verze 3.1)

//<input type="file" name="my-form[details][avatar]" multiple>
$file = $request->getFile(['my-form', 'details', 'avatar']);

Protože nelze důvěřovat datům zvenčí a tedy ani spoléhat na podobu struktury souborů, je bezpečnější tento způsob než třeba $request->getFiles()['my-form']['details']['avatar'], který může selhat.

getFiles(): array

Vrátí strom všech uploadů v normalizované struktuře, jejíž listy jsou objekty Nette\Http\FileUpload:

$files = $httpRequest->getFiles();

getCookie(string $key): string|array|null

Vrací cookie nebo null, když neexistuje.

$sessId = $httpRequest->getCookie('sess_id');

getCookies(): array

Vrací všechny cookies.

$cookies = $httpRequest->getCookies();

getMethod(): string

Vrací HTTP metodu, se kterou byl udělán požadavek.

$httpRequest->getMethod(); // GET, POST, HEAD, PUT

isMethod(string $method)bool

Testuje HTTP metodu, se kterou byl udělán požadavek. Parametr je case-insensitive.

if ($httpRequest->isMethod('GET')) // ...

getHeader(string $header): ?string

Vrací HTTP hlavičku nebo null, pokud neexistuje. Parametr je case-insensitive.

$userAgent = $httpRequest->getHeader('User-Agent');

getHeaders(): array

Vrací všechny HTTP hlavičky jako asociativní pole.

$headers = $httpRequest->getHeaders();
echo $headers['Content-Type'];

isSecured(): bool

Je spojení šifrované (HTTPS)? Pro správnou funkčnost může být potřeba nastavit proxy.

isSameSite(): bool

Přichází požadavek ze stejné (sub)domény a je iniciován kliknutím na odkaz? Nette k detekci používá cookie _nss (dříve nette-samesite).

isAjax(): bool

Jde o AJAXový požadavek?

getRemoteAddress(): ?string

Vrací IP adresu uživatele. Pro správnou funkčnost může být potřeba nastavit proxy.

getRemoteHost(): ?string

Vrací DNS překlad IP adresy uživatele. Pro správnou funkčnost může být potřeba nastavit proxy.

getBasicCredentials(): ?string

Vrací ověřovací údaje pro Basic HTTP authentication.

[$user, $password] = $httpRequest->getBasicCredentials();

getRawBody(): ?string

Vrací tělo HTTP požadavku.

$body = $httpRequest->getRawBody();

detectLanguage(array $langs): ?string

Detekuje jazyk. Jako parametr $lang předáme pole s jazyky, které aplikace podporuje, a ona vrátí ten, který by viděl návštěvníkův prohlížeč nejraději. Nejsou to žádná kouzla, jen se využívá hlavičky Accept-Language. Pokud nedojde k žádné shodě, vrací null.

// prohlížeč odesílá např. Accept-Language: cs,en-us;q=0.8,en;q=0.5,sl;q=0.3

$langs = ['hu', 'pl', 'en']; // jazyky podporované aplikací
echo $httpRequest->detectLanguage($langs); // en

RequestFactory

Objekt aktuálního HTTP requestu vyrobí Nette\Http\RequestFactory. Pokud píšete aplikaci, která nepoužívá DI kontejner, vyrobíte request takto:

$factory = new Nette\Http\RequestFactory;
$httpRequest = $factory->fromGlobals();

RequestFactory lze před zavoláním fromGlobals() konfigurovat. Můžeme vypnout sanitizaci vstupních parametrů od kontrolních znaků a neplatných UTF-8 sekvencí pomocí $factory->setBinary(). A také nastavit proxy server pomocí $factory->setProxy(...), což je důležité pro správnou detekci IP adresy uživatele.

Pomocí tzv. filtrů lze URL vyčistit od znaků, které se do něj mohou dostat např. kvůli špatně implementovaným komentářovým systémům na různých cizích webech:

// odstraníme mezery z cesty
$requestFactory->urlFilters['path']['%20'] = '';

// odstraníme tečku, čárku nebo pravou závorku z konce URI
$requestFactory->urlFilters['url']['[.,)]$'] = '';

// vyčistíme cestu od zdvojených lomítek (výchozí filtr)
$requestFactory->urlFilters['path']['/{2,}'] = '/';

Uploadované soubory

Metoda Nette\Http\Request::getFiles() vrací pole všech uploadů v normalizované struktuře, jejíž listy jsou objekty Nette\Http\FileUpload. Ty zapouzdřují data odeslaná formulářovým prvkem <input type=file>.

Struktura reflektuje pojmenování prvků v HTML. V nejjednodušším případě to může být jediný pojmenovaný element formuláře odeslaný jako:

<input type="file" name="avatar">

V tomto případě $request->getFiles() vrací pole:

[
	'avatar' => /* FileUpload instance */
]

Objekt FileUpload se vytvoří i v případě, že uživatel žádný soubor neodeslal nebo odeslání selhalo. Jestli byl soubor odeslán vrací metoda hasFile():

$request->getFile('avatar')->hasFile();

V případě názvu elementu používajícího notaci pro pole:

<input type="file" name="my-form[details][avatar]">

vypadá vrácený strom takto:

[
	'my-form' => [
		'details' => [
			'avatar' => /* FileUpload instance */
		],
	],
]

Lze vytvořit i pole souborů:

<input type="file" name="my-form[details][avatars][]" multiple>

V takovém případě vypadá struktura takto:

[
	'my-form' => [
		'details' => [
			'avatars' => [
				0 => /* FileUpload instance */,
				1 => /* FileUpload instance */,
				2 => /* FileUpload instance */,
			],
		],
	],
]

Přistoupit k indexu 1 vnořeného pole lze nejlépe takto:

$file = $request->getFile(['my-form', 'details', 'avatars', 1]);
// ve verzi 3.0 použijte:
//$file = Nette\Utils\Arrays::get(
//  $request->getFiles(),
//  ['my-form', 'details', 'avatars', 1],
//  null
//);
if ($file instanceof FileUpload) {
	// ...
}

Protože nelze důvěřovat datům zvenčí a tedy ani spoléhat na podobu struktury souborů, je bezpečnější tento způsob než třeba $request->getFiles()['my-form']['details']['avatars'][1], který může selhat.

Přehled metod FileUpload

hasFile(): bool

Vrací true, pokud uživatel nějaký soubor uploadoval.

isOk(): bool

Vrací true, pokud soubor byl nahrán úspěšně.

getError(): int

Vrací kód chyby při uploadu souboru. Jde o jednu z konstant UPLOAD_ERR_XXX. V případě, že upload proběhl v pořádku, vrací UPLOAD_ERR_OK.

move(string $dest)

Přesune nahraný soubor do nového umístění. Pokud cílový soubor již existuje, bude přepsán.

$file->move('/path/to/files/name.ext');

getContents(): ?string

Vrací obsah uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací null.

getContentType(): ?string

Detekuje MIME content type uploadovaného souboru na základě jeho signatury. V případě, že upload nebyl úspěšný nebo detekce se nezdařila, vrací null.

Vyžaduje PHP rozšíření fileinfo.

getUntrustedName(): string

Vrací originální název souboru, jak jej odeslal prohlížeč. Dříve se metoda jmenovala getName().

Nevěřte hodnotě vrácené touto metodou. Klient mohl odeslat škodlivý název souboru s úmyslem poškodit nebo hacknout vaši aplikaci.

getSanitizedName(): string

Vrací sanitizovaný název souboru. Obsahuje pouze ASCII znaky [a-zA-Z0-9.-].

Od verze 3.0.5: Pokud název takové znaky neobsahuje, vrátí 'unknown'. Pokud je soubor obrázek ve formátu JPEG, PNG, GIF, nebo WebP, vrátí i správnou příponu.

Vyžaduje PHP rozšíření fileinfo.

getSuggestedExtension(): ?string

Vrací vhodnou příponu souboru (bez tečky) odpovídající zjištěnému MIME typu.

Vyžaduje PHP rozšíření fileinfo.

getUntrustedFullPath(): string

Vrací originální cestu k souboru, jak ji odeslal prohlížeč při uploadu složky. Celá cesta je dostupná pouze v PHP 8.1 a vyšším. V předchozích verzích tato metoda vrací originální název souboru.

Nevěřte hodnotě vrácené touto metodou. Klient mohl odeslat škodlivý název souboru s úmyslem poškodit nebo hacknout vaši aplikaci.

getSize(): int

Vrací velikost uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací 0.

getTemporaryFile(): string

Vrací cestu k dočasné lokaci uploadovaného souboru. V případě, že upload nebyl úspěšný, vrací ''.

isImage(): bool

Vrací true, pokud nahraný soubor je obrázek ve formátu JPEG, PNG, GIF, nebo WebP. Detekce probíhá na základě jeho signatury a neověřuje se integrita celého souboru. Zda není obrázek poškozený lze zjistit například pokusem o jeho načtení.

Vyžaduje PHP rozšíření fileinfo.

getImageSize(): ?array

Vrací dvojici [šířka, výška] s rozměry uploadovaného obrázku. V případě, že upload nebyl úspěšný nebo nejde o platný obrázek, vrací null.

getImageFileExtension(): ?string

Vrátí příponu souboru obrázku na základě zjištěného typu obsahu (bez tečky).

toImage(): Nette\Utils\Image

Načte obrázek jak objekt Image. V případě, že upload nebyl úspěšný nebo nejde o platný obrázek, vyhodí výjimku Nette\Utils\ImageException.