Start Beiträge verschlagwortet mit "init"

Schlagwort: init

[ABAP] REDUCE: Kosten (Wertetabelle) summieren und neue Summentabelle erzeugen 

TYPES: BEGIN OF ty_s_kosten,
         k1 TYPE decfloat16,
         k2 TYPE decfloat16,
       END OF ty_s_kosten.

TYPES: ty_it_kosten TYPE STANDARD TABLE OF ty_s_kosten WITH EMPTY KEY.
TYPES: ty_it_sum TYPE STANDARD TABLE OF decfloat16 WITH EMPTY KEY.

DATA(it_kosten) = VALUE ty_it_kosten( ( k1 = '0.59' k2 = '1.48' )
                                      ( k1 = '1.28' k2 = '2.31' )
                                      ( k1 = '4.07' k2 = '2.35' ) ).

* Summen ausrechnen, neue Tabelle mit den Summen erstellen
DATA(it_sum) = REDUCE ty_it_sum(
* Initialwerte (leere Tabelle) für die Rückgabe (Typen bei REDUCE und VALUE müssen identisch sein)
                                 INIT sum = VALUE ty_it_sum( )
* alle Datensätze aus it_kosten
                                 FOR <k> IN it_kosten
* neue Elemente an it_sum anfügen, auf Basis der alten "sum"
                                 NEXT sum = VALUE #( BASE sum
                                                     ( <k>-k1 + <k>-k2 )
                                                   )
                               ).

* Ausgabe
cl_demo_output=>write_data( it_kosten ).
cl_demo_output=>write_data( it_sum ).
cl_demo_output=>display( ).

[ABAP] REDUCE: Fibonacci-Zahlen berechnen 

* Stringtabelle erstellen
DATA(it_fib) = REDUCE stringtab(
* Initialwerte
                                 INIT ret = VALUE stringtab( ( |0| ) ( |1| ) )
                                      x TYPE string
                                      y TYPE string
* 100 Durchläufe
                                 FOR n = 1 WHILE n < 101
* letztes und vorletztes Element der Liste ermitteln
                                 NEXT x   = ret[ lines( ret ) ]
                                      y   = ret[ lines( ret ) - 1 ]
* addieren und an bestehende Liste anfügen
                                      ret = VALUE #( BASE ret
                                                     ( x + y )
                                                   )
                               ).

* Ausgabe
cl_demo_output=>display( it_fib ).

[ABAP] REDUCE: Strings aus einer internen Tabelle verketten 

DATA(it_strings) = VALUE stringtab( ( |Udo| ) ( |Heinz| ) ( |Erika| ) ).

DATA(lv_concat_strings) = REDUCE string( INIT s = ||
                                         FOR <s> IN it_strings
                                         NEXT s = COND #( WHEN s IS INITIAL
                                                          THEN |{ <s> }|
                                                          ELSE |{ s }{ cl_abap_char_utilities=>cr_lf }{ <s> }|
                                                        )
                                       ).

WRITE: / lv_concat_strings.

[JavaScript] DOM: Buttonklick realisieren 

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0;">
  <title>DOM Buttonclick</title>
  <script>
  // Strict mode
  'use strict';

  // https://wiki.selfhtml.org/wiki/JavaScript/Module_und_Kapselung
  // private Scope deklarieren
  // anonyme Funktion 1
  (
      // anonyme Funktion 2
    function ()
    {
      // Initialisierung
      function init() {
        let btn = document.getElementById('btnTestButton');

        if (btn) {
          btn.addEventListener(
            "click",
            function () { txtout(); }
          );
        }
      }

      // Textausgabe
      function txtout() {
        let txt = document.getElementById("textfeld");
        if (txt) {
          txt.innerHTML = "Test1";
        }
      }

      // Event-Listener
      document.addEventListener(
        "DOMContentLoaded",
        function () { init(); }
      );
    }
    
    // Aufruf der inneren anonymen Funktion 2
    ()
  );
  </script>
</head>
<body>
    <p>Button klicken!</p>
    <button type="button" id="btnTestButton">Klick!</button>
    <div id="textfeld"></div>
</body>
</html>

[ABAP] REDUCE: Minimum / Maximum in einer internen Tabelle suchen 

* Maximum
DATA(lv_max) = 100.

* Zufallszahlen 1 ... lv_max
DATA(o_rand_i) = cl_abap_random_int=>create( seed = cl_abap_random=>seed( ) min = 1 max = lv_max ).

TYPES: ty_it_rand TYPE STANDARD TABLE OF i WITH DEFAULT KEY.

* Tabelle mit Zufallswerten
DATA(it_rand) = VALUE ty_it_rand( FOR v = 1 WHILE v < 11
                                  ( o_rand_i->get_next( ) ) ).

* Datenausgabe
LOOP AT it_rand ASSIGNING FIELD-SYMBOL(<r>).
  WRITE: / sy-tabix, ':', <r>.
ENDLOOP.

* Minimumsuche
DATA(min) = REDUCE i( INIT m = lv_max
                      FOR <v> IN it_rand
                      NEXT m = COND #( WHEN <v> < m THEN <v> ELSE m ) ).

WRITE: / 'Min:', min.

* Maximumsuche
DATA(max) = REDUCE i( INIT m = 0
                      FOR <v> IN it_rand
                      NEXT m = COND #( WHEN <v> > m THEN <v> ELSE m ) ).

WRITE: / 'Max:', max.

[ABAP] REDUCE: Spaltensumme eines Feldes einer internen Tabelle berechnen 

DATA: it_spfli TYPE STANDARD TABLE OF spfli.

* Daten holen
SELECT * FROM spfli INTO TABLE it_spfli.

* Daten ausgeben
LOOP AT it_spfli ASSIGNING FIELD-SYMBOL(<f>).
  WRITE: / <f>-carrid, <f>-connid, <f>-fltime.
ENDLOOP.

* Gesamtflugzeit berechnen (Summe)
DATA(lv_fltime_sum) = REDUCE spfli-fltime( INIT s = 0
                                           FOR <l> IN it_spfli
                                           NEXT s = s + <l>-fltime ).

* Gesamtflugzeit ausgeben
WRITE: / '--> Gesamtflugzeit:', lv_fltime_sum.

[ABAP] REDUCE: Anzahl bestimmter Datensätze in einer internen Tabelle zählen 

DATA: it_spfli TYPE STANDARD TABLE OF spfli.

* Daten holen
SELECT * FROM spfli INTO TABLE it_spfli.

* Daten ausgeben
LOOP AT it_spfli ASSIGNING FIELD-SYMBOL(<fs_spfli>).
  WRITE: / <fs_spfli>-carrid, <fs_spfli>-connid, <fs_spfli>-airpfrom, <fs_spfli>-airpto.
ENDLOOP.

* Datensätze für 'LH' zählen
DATA(lv_cnt_lh) = REDUCE i( INIT x = 0
                            FOR <l> IN it_spfli WHERE ( carrid = 'LH' )
                            NEXT x = x + 1 ).

* Anzahl 'LH'-Flüge ausgeben
WRITE: / '--> Anzahl LH-Flüge:', lv_cnt_lh.

[ABAP] Zufallszahlen erzeugen

Variante 1 (cl_abap_random)

* int - Zufallszahlen von 0...100 erzeugen
DATA(o_rand_i) = cl_abap_random_int=>create( seed = cl_abap_random=>seed( ) min = 0 max = 100 ).
DO 10 TIMES.
  WRITE: / o_rand_i->get_next( ).
ENDDO.

DATA(o_rand) = cl_abap_random=>create( cl_abap_random=>seed( ) ).
DO 10 TIMES.
  WRITE: / o_rand->intinrange( low = 0 high = 100 ).
ENDDO.

* float - Zufallszahlen im Bereich von 0...1 erzeugen
DATA(o_rand_f) = cl_abap_random_float=>create( seed = cl_abap_random=>seed( ) ).
DO 10 TIMES.
  WRITE: / |{ o_rand_f->get_next( ) NUMBER = ENVIRONMENT }|.
ENDDO.

DATA(o_rand) = cl_abap_random=>create( cl_abap_random=>seed( ) ).
DO 10 TIMES.
  WRITE: / |{ o_rand->float( ) NUMBER = ENVIRONMENT }|.
*  WRITE: / |{ o_rand->decfloat16( ) NUMBER = ENVIRONMENT }|.
*  WRITE: / |{ o_rand->decfloat34( ) NUMBER = ENVIRONMENT }|.
ENDDO.

Variante 2 (cl_random_number)

DATA(o_rnd) = NEW cl_random_number( ).
o_rnd->if_random_number~init( ).

DO 10 TIMES.
* Integer-Zahlen von 0 ... 100
  DATA(lv_i) = o_rnd->if_random_number~get_random_int( 100 ).
  WRITE: / lv_i.
ENDDO.

DO 10 TIMES.
* Float-Zahlen von 0 ... 1
  DATA(lv_f) = o_rnd->if_random_number~get_random_float( ).
  WRITE: / |{ lv_f NUMBER = ENVIRONMENT }|.
ENDDO.