Zelí nakrájíme na tenké nudličky a pokapeme šťávou z citrónu. Přidáme cukr, olivový olej, osolíme a opepříme. Salát silně promačkáme tak, aby pustil šťávu. Na závěr přidáme nahrubo nastrouhanou mrkev a promícháme.Pekingské zelí krájíme hlavně do salátů, a to slaných i sladkých s ovocem. Dále se hodí do masových, bramborových, zeleninových, rybích, houbových jídel, a to restovaných, dušených i pečených. Specialitou dánské kuchyně je Pečené čínské zelí. Zjemní chuť každého pokrmu, především uzenin - Pekingské zelí se šunkou.Zelí nakrájíme na nudličky, cibuli nadrobno, rajčata na osminky, okurku na kostičky papriku na tenké proužky a mrkev nahrubo nastrouháme. Všechnu zeleninu dáme do mísy a opatrně smícháme. Zalijeme zálivkou z oleje, octa a cukru nebo přidáme tatarskou omáčku. Salát opatrně promícháme a dáme vychladit.
Jak uchovat pekingské zelí : Pekingské zelí lze snadno skladovat v chladničce v zásuvce na zeleninu; zabalené do fólie vydrží jeden až dva týdny.
Jak ochutit bile kysane zeli : Kysané zelí má svou vlastní kyselost, obvykle se tedy už nemusí ničím dalším dokyselovat a stačí mu jen dosladit. Oproti tomu čerstvé zelí se musí dochutit octem, ať už běžným kvasným lihovým, nebo třeba vinným. Dokyselování se vždy děje až na samotný závěr dušení, v kyselém prostředí by zelí nezměklo.
Pekingské zelí se v kuchyni používá zejména do zeleninových a ovocných salátů nebo do burgrů, hot dogů a sendvičů místo salátu. Dá se také vařit, dusit i zapékat, hodí se do bramborových, masových, houbových pokrmů. Velké listy lze použít k tvorbě masem plněných závitků.
Z čínského zelí připravíte zdravý salát. Můžete být vhodnou přílohou k obědu nebo, smíchaný se zeleninou a vajíčkem, jako zdravá večeře. Výborný je recept na salát z čínského zelí s jogurtovým dresinkem. Nebo si připravte závitky z čínského zelí s masem.
Poprášení moukou: Nejjednodušší způsob zahuštění spočívá v poprášení moukou, když už se dušení zelí blíží ke konci. Žádná jíška, žádná zápražka, žádné dlouhé prováření. Tohle je těch slibovaných pět vteřin, víc není potřeba. Přes malý cedníček obdaříte měkké zelí lehkým popraškem hladké mouky.Jak udělat Kysané zelí ke Kachne : Zelí: Kysané zelí propláchneme, zalijeme vodou a vaříme. Osmažíme cibulku, přidáme hladkou mouku, uděláme jíšku, kterou př arguments.
* @param string $output Used to append additional content (passed by reference).
*/
public function display_element( $element, &$children_elements, $max_depth, $depth, $args, &$output ) {
if ( ! $element ) {
return;
}
$max_depth = (int) $max_depth;
$depth = (int) $depth;
$id_field = $this->db_fields['id'];
$id = $element->$id_field;
// Display this element.
$this->has_children = ! empty( $children_elements[ $id ] );
if ( isset( $args[0] ) && is_array( $args[0] ) ) {
$args[0]['has_children'] = $this->has_children; // Back-compat.
}
$this->start_el( $output, $element, $depth, ...array_values( $args ) );
// Descend only when the depth is right and there are children for this element.
if ( ( 0 === $max_depth || $max_depth > $depth + 1 ) && isset( $children_elements[ $id ] ) ) {
foreach ( $children_elements[ $id ] as $child ) {
if ( ! isset( $newlevel ) ) {
$newlevel = true;
// Start the child delimiter.
$this->start_lvl( $output, $depth, ...array_values( $args ) );
}
$this->display_element( $child, $children_elements, $max_depth, $depth + 1, $args, $output );
}
unset( $children_elements[ $id ] );
}
if ( isset( $newlevel ) && $newlevel ) {
// End the child delimiter.
$this->end_lvl( $output, $depth, ...array_values( $args ) );
}
// End this element.
$this->end_el( $output, $element, $depth, ...array_values( $args ) );
}
/**
* Displays array of elements hierarchically.
*
* Does not assume any existing order of elements.
*
* $max_depth = -1 means flatly display every element.
* $max_depth = 0 means display all levels.
* $max_depth > 0 specifies the number of display levels.
*
* @since 2.1.0
* @since 5.3.0 Formalized the existing `...$args` parameter by adding it
* to the function signature.
*
* @param array $elements An array of elements.
* @param int $max_depth The maximum hierarchical depth.
* @param mixed ...$args Optional additional arguments.
* @return string The hierarchical item output.
*/
public function walk( $elements, $max_depth, ...$args ) {
$output = '';
$max_depth = (int) $max_depth;
// Invalid parameter or nothing to walk.
if ( $max_depth < -1 || empty( $elements ) ) {
return $output;
}
$parent_field = $this->db_fields['parent'];
// Flat display.
if ( -1 === $max_depth ) {
$empty_array = array();
foreach ( $elements as $e ) {
$this->display_element( $e, $empty_array, 1, 0, $args, $output );
}
return $output;
}
/*
* Need to display in hierarchical order.
* Separate elements into two buckets: top level and children elements.
* Children_elements is two dimensional array. Example:
* Children_elements[10][] contains all sub-elements whose parent is 10.
*/
$top_level_elements = array();
$children_elements = array();
foreach ( $elements as $e ) {
if ( empty( $e->$parent_field ) ) {
$top_level_elements[] = $e;
} else {
$children_elements[ $e->$parent_field ][] = $e;
}
}
/*
* When none of the elements is top level.
* Assume the first one must be root of the sub elements.
*/
if ( empty( $top_level_elements ) ) {
$first = array_slice( $elements, 0, 1 );
$root = $first[0];
$top_level_elements = array();
$children_elements = array();
foreach ( $elements as $e ) {
if ( $root->$parent_field === $e->$parent_field ) {
$top_level_elements[] = $e;
} else {
$children_elements[ $e->$parent_field ][] = $e;
}
}
}
foreach ( $top_level_elements as $e ) {
$this->display_element( $e, $children_elements, $max_depth, 0, $args, $output );
}
/*
* If we are displaying all levels, and remaining children_elements is not empty,
* then we got orphans, which should be displayed regardless.
*/
if ( ( 0 === $max_depth ) && count( $children_elements ) > 0 ) {
$empty_array = array();
foreach ( $children_elements as $orphans ) {
foreach ( $orphans as $op ) {
$this->display_element( $op, $empty_array, 1, 0, $args, $output );
}
}
}
return $output;
}
/**
* Produces a page of nested elements.
*
* Given an array of hierarchical elements, the maximum depth, a specific page number,
* and number of elements per page, this function first determines all top level root elements
* belonging to that page, then lists them and all of their children in hierarchical order.
*
* $max_depth = 0 means display all levels.
* $max_depth > 0 specifies the number of display levels.
*
* @since 2.7.0
* @since 5.3.0 Formalized the existing `...$args` parameter by adding it
* to the function signature.
*
* @param array $elements An array of elements.
* @param int $max_depth The maximum hierarchical depth.
* @param int $page_num The specific page number, beginning with 1.
* @param int $per_page Number of elements per page.
* @param mixed ...$args Optional additional arguments.
* @return string XHTML of the specified page of elements.
*/
public function paged_walk( $elements, $max_depth, $page_num, $per_page, ...$args ) {
$output = '';
$max_depth = (int) $max_depth;
if ( empty( $elements ) || $max_depth < -1 ) {
return $output;
}
$parent_field = $this->db_fields['parent'];
$count = -1;
if ( -1 === $max_depth ) {
$total_top = count( $elements );
}
if ( $page_num < 1 || $per_page < 0 ) {
// No paging.
$paging = false;
$start = 0;
if ( -1 === $max_depth ) {
$end = $total_top;
}
$this->max_pages = 1;
} else {
$paging = true;
$start = ( (int) $page_num - 1 ) * (int) $per_page;
$end = $start + $per_page;
if ( -1 === $max_depth ) {
$this->max_pages = (int) ceil( $total_top / $per_page );
}
}
// Flat display.
if ( -1 === $max_depth ) {
if ( ! empty( $args[0]['reverse_top_level'] ) ) {
$elements = array_reverse( $elements );
$oldstart = $start;
$start = $total_top - $end;
$end = $total_top - $oldstart;
}
$empty_array = array();
foreach ( $elements as $e ) {
++$count;
if ( $count < $start ) {
continue;
}
if ( $count >= $end ) {
break;
}
$this->display_element( $e, $empty_array, 1, 0, $args, $output );
}
return $output;
}
/*
* Separate elements into two buckets: top level and children elements.
* Children_elements is two dimensional array, e.g.
* $children_elements[10][] contains all sub-elements whose parent is 10.
*/
$top_level_elements = array();
$children_elements = array();
foreach ( $elements as $e ) {
if ( empty( $e->$parent_field ) ) {
$top_level_elements[] = $e;
} else {
$children_elements[ $e->$parent_field ][] = $e;
}
}
$total_top = count( $top_level_elements );
if ( $paging ) {
$this->max_pages = (int) ceil( $total_top / $per_page );
} else {
$end = $total_top;
}
if ( ! empty( $args[0]['reverse_top_level'] ) ) {
$top_level_elements = array_reverse( $top_level_elements );
$oldstart = $start;
$start = $total_top - $end;
$end = $total_top - $oldstart;
}
if ( ! empty( $args[0]['reverse_children'] ) ) {
foreach ( $children_elements as $parent => $children ) {
$children_elements[ $parent ] = array_reverse( $children );
}
}
foreach ( $top_level_elements as $e ) {
++$count;
// For the last page, need to unset earlier children in order to keep track of orphans.
if ( $end >= $total_top && $count < $start ) {
$this->unset_children( $e, $children_elements );
}
if ( $count < $start ) {
continue;
}
if ( $count >= $end ) {
break;
}
$this->display_element( $e, $children_elements, $max_depth, 0, $args, $output );
}
if ( $end >= $total_top && count( $children_elements ) > 0 ) {
$empty_array = array();
foreach ( $children_elements as $orphans ) {
foreach ( $orphans as $op ) {
$this->display_element( $op, $empty_array, 1, 0, $args, $output );
}
}
}
return $output;
}
/**
* Calculates the total number of root elements.
*
* @since 2.7.0
*
* @param array $elements Elements to list.
* @return int Number of root elements.
*/
public function get_number_of_root_elements( $elements ) {
$num = 0;
$parent_field = $this->db_fields['parent'];
foreach ( $elements as $e ) {
if ( empty( $e->$parent_field ) ) {
++$num;
}
}
return $num;
}
/**
* Unsets all the children for a given top level element.
*
* @since 2.7.0
*
* @param object $element The top level element.
* @param array $children_elements The children elements.
*/
public function unset_children( $element, &$children_elements ) {
if ( ! $element || ! $children_elements ) {
return;
}
$id_field = $this->db_fields['id'];
$id = $element->$id_field;
if ( ! empty( $children_elements[ $id ] ) && is_array( $children_elements[ $id ] ) ) {
foreach ( (array) $children_elements[ $id ] as $child ) {
$this->unset_children( $child, $children_elements );
}
}
unset( $children_elements[ $id ] );
}
}
Fatal error: Uncaught Error: Class 'Walker' not found in /var/www/bitok/data/www/bigbeach-fes.com/wp-includes/class-walker-page.php:17
Stack trace:
#0 /var/www/bitok/data/www/bigbeach-fes.com/wp-settings.php(212): require()
#1 /var/www/bitok/data/www/bigbeach-fes.com/wp-config.php(83): require_once('/var/www/bitok/...')
#2 /var/www/bitok/data/www/bigbeach-fes.com/wp-load.php(50): require_once('/var/www/bitok/...')
#3 /var/www/bitok/data/www/bigbeach-fes.com/wp-blog-header.php(13): require_once('/var/www/bitok/...')
#4 /var/www/bitok/data/www/bigbeach-fes.com/index.php(17): require('/var/www/bitok/...')
#5 {main}
thrown in /var/www/bitok/data/www/bigbeach-fes.com/wp-includes/class-walker-page.php on line 17