| SYNOPSIS |
| mixed arr[index]; |
| int str[index]; |
| |
| *mixed arr[from .. to]; |
| string str[from .. to]; |
| |
| BESCHREIBUNG |
| Liefert ein Element aus einem Array oder String (erste Form), oder |
| eine Teilmenge (zweite Form). |
| |
| Die Indizes <index>, <from> und <to> sind durchnummeriert von 0 bis |
| strlen(<str>)-1 bzw. sizeof(<arr>)-1. Wenn ein <index> als '<wert' |
| geschrieben wird, wird der Wert vom Ende des Stings / Arrays her |
| gezaehlt. Dabei wird nummeriert von 1 bis strlen(<str>) bzw. |
| sizeof(<arr>). Wird <from> weggelassen, beginnt die Teilmenge mit |
| dem ersten Element. Wird <to> weggelassen, endet die Teilmenge mit |
| dem letzten Element. |
| |
| In der ersten Form muss <index> innerhalb der Grenzen des Strings / |
| Arrays sein, sonst wird ein Laufzeitfehler (RTE) verursacht. In der |
| zweiten Form werden die Indizes an die Groesse des Strings / Arrays |
| angepasst. Wenn <from> groesser ist als <to> oder beide ausserhalb |
| der Groesse des Strings / Arrays liegen, wird ein leerer String "" |
| bzw. ein leeres Array ({}) zurueck geliefert. |
| |
| Die Notation als Closure ist entsprechend: |
| |
| [index] -> ({'#[, arr, index }) |
| [<index] -> ({'#[<, arr, index }) |
| [from..to] -> ({'#[..], arr, from, to }) |
| [<from..to] -> ({'#[<..], arr, from, to }) |
| [from..<to] -> ({'#[..<], arr, from, to }) |
| [<from..<to] -> ({'#[<..<], arr, from, to }) |
| |
| BEISPIELE |
| foo = ({ 1, 2, 3, 4 }); str = "test"; |
| |
| foo[1] -> 1 str[1] -> 'e' == 101 |
| foo[1..2] -> ({ 2, 3 }) str[1..2] -> "es" |
| foo[2..1] -> ({ }) str[2..1] -> "" |
| foo[0..<2] -> ({ 1, 2 }) str[0..<2] -> "tes" |
| |
| foo[..<2] -> ({ 1, 2 }) str[..<2] -> "tes" |
| foo[<3..] -> ({ 2, 3, 4 }) str[<3..] -> "est" |
| |
| foo[1] = 5 -> foo == ({ 1, 5, 3, 4 }) |
| foo[1..2] = ({ 5, 6, 7 }) -> foo == ({ 1, 5, 6, 7, 4 }) |
| foo[1..2] = ({ }) -> foo == ({ 1, 4 }) |
| |
| str[1] = 'a' -> str == "tast" |
| str[1..2] = "bar" -> str == "tbart" |
| str[1..2] = "" -> str == "tt" |
| |
| AENDERUNGEN |
| slice_array() ist die alte Form der []-Operatoren fuer Arrays, |
| extract() ist die alte Form der []-Operatoren fuer Strings. |
| BEIDE VARIANTEN SIND VERALTET, WERDEN NICHT MEHR UNTERSTUETZT UND |
| SOLLTEN DESHALB NICHT MEHR VERWENDET WERDEN. |
| |
| Die Syntax fuer 'rueckwaerts zaehlen vom letzten Element' hat sich von |
| Version 3.1.J zu 3.1.K geaendert von '-1' zu '<1'. Auch ist seit dann |
| foo[0..-1] ein leeres Array bzw. ein leerer String. |
| |
| SIEHE AUCH |
| member(E), sizeof(E), slice_array(E) |