Hinweise [mehr]

ECMAScript ( Arrays )

Nächste Vorherige Lösung Punkte

Der folgende ECMAScript-Quellcode erstellt mit s1 den Array a1. Mit 3 "for-Schleifen" werden die Array-Element von a2, a3, a4 mit Hilfe von .push() initialisiert. Richtige Aussagen bitte ankreuzen.
<script>
var a1=[ ], a2=[ ], a3=[ ], a4=[ ], i, s1="äöüABC"; 
    a1 = s1.split('');

for(i = 0; i < a1.length; i += 1) {
  a2.push( a1[i].charCodeAt(0).toString(32) );
}
for(i = 0; i < a2.length; i += 1) {
  a3.push( parseInt(a2[i],32) );
}
for(i = 0; i < a3.length; i += 1) {
  a4.push( String.fromCharCode(a3[i]) );
}
</script>
Die Ausgabe von a1.join('|') zeigt den String "ä|ö|ü|A|B|C"
Die Ausgabe von a2 zeigt den Array ['74','7m','7s','21','22','23']
Die Ausgabe von a3 zeigt den Array ['228','246','252','65','66','67']
Die Ausgabe von a4.join('|') zeigt den String "ä|ö|ü|A|B|C"
Es geht um den Array var arr = ['A', 'B', 'C', 'D']; und insbesondere um arr.length. Welche Ausgaben erstellt angegebene Funktion debug(r, arr, i ) ? Richtige Aussagen bitte anhaken.
<script>
function debug(r, arr, i) { 
  var s = "\ni = III mit [ARR], length=LLL, arr[i]=VAL"; 
  s = s.replace("III", i);
  s = s.replace("ARR", arr.join('|'));
  s = s.replace("LLL", arr.length)
       .replace("VAL", arr[i]);
  r.push( s ); alert( r[i] );
} 

var arr = ['A', 'B', 'C', 'D'],
r = [ ];           debug(r, arr, 0 );
delete arr[1];     debug(r, arr, 1 );
arr.splice(1, 1);  debug(r, arr, 2 );
</script>
debug(r, arr, 0 ) zeigt an: "i = 0 mit [A|B|C|D], length=4, arr[i]=A"
debug(r, arr, 1 ) zeigt an: "i = 1 mit [A||C|D], length=4, arr[i]=undefined"
debug(r, arr, 2 ) zeigt an: "i = 2 mit [A|C|D], length=3, arr[i]=D"
Betrachten sie bitte das folgende Code-Schnipsel:
<script>
var arr = [, ("42" ==  42),
             ("42" === 42),
             ("42" !=  42),
             ("42" !== 42) ];
 
       arr[0] = typeof arr[0];
       arr[6] = typeof arr[6];
       arr[7] = !arr[5];
       arr[5] = !arr[7];
 alert(arr.join('\n'));
</script>
Welche Ergebnisse sind richtig?
Bei "var arr = [, ..." liegt ein Syntaxfehler vor (Komma).
arr[0] und arr[6] sind vom Typ undefined
arr[1], arr[4], arr[7] haben den Wert true
arr[2], arr[3], arr[5] haben den Wert false
Es werden die Property-Werte eines Objekt-Literals obj werden in den Array arr 'gepushed' und mit arr.join(separator-String) zu einem String verkettet. Richtige Aussagen bitte ankreuzen.
<div id="my_test_div">/*1*/</div>
<script>

var ss = '', /*2*/ 
  obj = { a:'A', 
         'b': 'B', 
         'c-char': 'C', 
         '1': 123
  }, arr = [ ]; 

  arr.push(obj.a); /*3*/ 
  arr.push(obj.b);
  arr.push(obj['a']);
  arr.push(obj['c-char']); 
  ss = arr.join(' | ');

window.onload = function() { /*4*/ 
  document.getElementById('my_test_div').innerHTML = ss;
};
</script>
Bei /*1*/ ist ein div-Tag id="my_test_div", das var divElement=document.getElementById('my_test_div'); und divElement.innerHTML = "/*1*/"; entspricht.
Bei /*2*/ beginnen die Variablen-Deklaration, bei /*3*/ enden die Variablen-Deklaration und es folgen Statements.
Die Statements bei /*4*/, d.h. in window.onload = function() {...}; werden ausgeführt, nachdem die Seite vollständig geladen wurde. Das Statements bei /*4*/ wird nur einmal ausgeführt. Eine HTML-Seite kann mehrere Anweisungen window.onload = function() {...}; haben.
Siehe bei /*3*/. Die Schreibweise obj['a'] kann hier durch die einfachere Schreibweise obj.a ersetzt werden.
Siehe bei /*3*/. Es ist nicht möglich, die Schreibweise obj['c-char']) durch obj.c-char zu ersetzen.
Bevor die HTML-Seite nicht fertig geladen ist, zeigt das div-Tag id="my_test_div" die Zeichenkette "/*1*/" an.
Nachdem die HTML-Seite fertig geladen ist, zeigt das div-Tag id="my_test_div" die Zeichenkette "A | B | A | C" an.
Ein Array arr habe 6 Elemente. Mit arr.indexOf(SuchWert) kann in arr der SuchWert von links und mit arr.lastIndexOf(SuchWert) der SuchWert von rechts gesucht werden.
<script>
 var arr = [67, 'C', 0x42, 'B', 65, 'A'];

 var r = [arr.indexOf('A'), arr.lastIndexOf('A'),
          arr.indexOf('C', 2), arr.lastIndexOf('C', 2),
          arr.indexOf(65, 4), arr.lastIndexOf(65, 4)
         ];
</script>
arr.indexOf('A') ergibt r[0] = 5
arr.lastIndexOf('A') ergibt r[1] = 5
arr.indexOf('C', 2) ergibt r[2] = -1
arr.lastIndexOf('C', 2) ergibt r[3] = 1
arr.indexOf(65, 4) ergibt r[4] = 4
arr.lastIndexOf(65, 4) ergibt r[5] = 4
Das folgende Codefragment verwendet ist zu durchdenken. Es werden a.push() und alternativ a[i] = Wert verwendet. Welche Aussagen sind richtig?
<script>
function test(o) { return (o && o.length === +o.length); }

var a = [ ];
a.push( test( [ 0, 1, 2, 3, 4 ] ));
a.push( test( "abcdefghijklmno" ));
a.push( test( { a:'A', b:'B' }  ));
a.push( test(   123456789       ));
a.push( test(   document        ));
a.push( 'a.length = ' + a.length );

alert('erg1 = [' + a.join(', ') + '];' );

a[0] = test( [ 0, 1, 2, 3, 4 ] );
a[1] = test( "abcdefghijklmno" );
a[2] = test( { a:'A', b:'B' }  );
a[3] = test(   123456789       );
a[4] = test(   document        );
a[5] = 'a.length = ' + a.length;

alert('erg2 = [' + a.join(', ') + '];' );
</script>
Als Anzeige ergibt sich erg1 = [true, true, false, false, false, a.length = 5];
Als Anzeige ergibt sich erg2 = [true, true, false, false, false, a.length = 6];
Wird das obige (o && o.length === +obj.length); durch
(o && o.length == o.length); ersetzt, so ergibt sich erg1 = [true, true, true, true, true, a.length = 5];
Die folgende Funktion arr_to_obj() gibt ein Objekt zurück. Richtige Antworten bitte ankreuzen.
<script>
function arr_to_obj(arr, val) {
  var i, a, obj = {};
  for(i = 0; a = arr[i]; i += 1){
    obj[a] =   val + '=' +a;
  } return obj;
}

var obj = arr_to_obj(['0', 'a', "2", 1, 0], "key");

</script>
document.write(obj['0']) gibt key=0 aus
document.write(obj['a']) gibt key=a aus
document.write(obj["2"]) gibt key=2 aus
document.write(obj["1"]) gibt key=1 aus
document.write(obj[ 1 ]) gibt key=1 aus
document.write(obj[ 0 ]) gibt key=0 aus
Das Objekt obj enthält 4 Properties
Der Aufruf von arr.every(callback_function [, thisArg]) bewirkt die callback_function(arr[i])-Aufrufe. Bei der ersten false-Rückgabe der callback_function(arr[i]) gibt arr.every() false zurück. Richtige Aussage bitte ankreuzen.
  
<script>
var val_gerade = function (val) { 
                  return !(val % 2); },
str_nicht_leer = function (str) { 
                   return (str && str !== ''); },
 a = [ 0x42, 66, 68],
 b = [   66, 67, 68],
 c = [  'A', 'B',  ],
 d = [             ],
 r = [ (a[0] === a[1]),
       a.every(val_gerade),
       b.every(val_gerade),
       c.every(str_nicht_leer),
       d.every(str_nicht_leer) ];
</script>
Der Wert von (a[0] === a[1]) ergibt r[0] = false;
Der Aufruf von a.every(val_gerade) ergibt r[1] = true;
Der Aufruf von b.every(val_gerade) ergibt r[2] = false;
Der Aufruf von c.every(str_nicht_leer) ergibt r[3] = true;
Der Aufruf von d.every(str_nicht_leer) ergibt r[4] = true;
Das folgende Codefragment ist zu durchdenken. Welche Aussagen sind richtig?
<script>
function test(obj) {
  return (obj && obj.length === +obj.length);
}

var a = [ ];
a.push( test( [ 0, 1, 2, 3, 4 ] ));
a.push( test( "abcdefghijklmno" ));
a.push( test( { a:'A', b:'B' }  ));
a.push( test(   123456789       ));
a.push( test(   document        ));
alert('erg1 = [' + a.join(', ') + '];' );

a[0] = test( [ 0, 1, 2, 3, 4 ] );
a[1] = test( "abcdefghijklmno" );
a[2] = test( { a:'A', b:'B' }  );
a[3] = test(   123456789       );
a[4] = test(   document        );
alert('erg2 = [' + a.join(', ') + '];' );
</script>
Als Anzeige ergibt sich erg1 = [true, true, false, false, false];
Als Anzeige ergibt sich erg2 = [true, true, false, false, false];
Wird das obige (obj && obj.length === +obj.length); durch
(obj && obj.length === +obj.length); ersetzt, so ergibt sich erg1 = [true, true, true, true, true];
Der Aufruf von arr.some(callback_function [, thisArg]) bewirkt die callback_function(arr[i])-Aufrufe. Bei der ersten true-Rückgabe der callback_function(arr[i][,i[,arr]]) gibt arr.some() true zurück. Richtige Aussage bitte ankreuzen.
<script>
var val_gerade = function (val) {
                 return !(val % 2); },
str_nicht_leer = function (str) {
                 return (str && str !== ''); },
 a = [  0x42, 66, 68 ],
 b = [   66,  67, 68 ],
 c = [  'A', 'B',    ],
 d = [               ],

 r = [ a.some(val_gerade),
       b.some(val_gerade),
       c.some(str_nicht_leer),
       d.some(str_nicht_leer) ];
</script>
Der Aufruf von a.some(val_gerade) ergibt r[0] = true;
Der Aufruf von b.some(val_gerade) ergibt r[1] = true;
Der Aufruf von c.some(str_nicht_leer) ergibt r[2] = true;
Der Aufruf von d.some(str_nicht_leer) ergibt r[3] = false;
Der Aufruf von arr.filter(callback_function [, thisArg]) erstellt einen neuen Array mit den Elementen, für die die callback_function true zurück gibt. Richtige Aussage bitte ankreuzen.
<script>
function is_str(str) { return (typeof str === 'string'); };

function is_num(val) { return (typeof val === 'number'); };

var a = [0x41, 'A', 66, 'B', 67, "\u0043"],

num = a.filter(is_num),

str = a.filter(is_str);
    alert(num + '\n' + str)
</script>
Der Aufruf von a.filter(is_num) macht aus dem a-Array den num-Array aa = [65,66,67]
Der Aufruf von a.filter(is_num) macht aus dem a-Array den num-Array aa = [66,67]
Der Aufruf von a.filter(is_num) macht aus dem a-Array den str-Array aa = [A,B,C]
Der Aufruf von arr.map(callback_function [, thisArg]) bewirkt die callback_function(arr[i][,i[,arr]])-Aufrufe. arr.map(callback_function [, thisArg]) gibt einen neuen Array zurück. Nun liegen 3 Array's a, b, c vor. Richtige Aussage zu aa, bb, cc bitte ankreuzen.
<script>
    var 
 a = [0x42, 67, 68],
 b = ['A', 1, 2],
 c = [66, 68, 70, 3],


 aa = a.map(function (el, i) { return 100 * el + i; }),

 bb = b.map(function (el) { return (~el >>> 0).toString(16); }),

 cc = c.map(function (el, i) { return c[i] - (a[i] || 0); });
</script>
Der Aufruf von a.map() macht aus dem a-Array den aa-Array aa = [6600,6701,6802]
Der Aufruf von b.map() macht aus dem b-Array den aa-Array bb = [ffffffff,fffffffe,fffffffd]
Der Aufruf von c.map() macht aus dem c-Array den aa-Array cc = [0,1,2,3]
Der Aufruf von arr.forEach(callback_function [, thisArg]) bewirkt die callback_function(arr[i][,i[,arr]])-Aufrufe. arr.forEach(callback_function [, thisArg]) gibt undefined zurück. Nun liegen 3 Array's a, b, c vor. Richtige Aussage zu a.forEach(), b.forEach(), c.forEach() bitte ankreuzen.
<script>
    var a = [0x42, 67, 68],
    b = ['A', 1, 2],
    c = [1, 2, 3, 14];

    a.forEach(function (el, i) {
        a[i] = 10 * el;
    });
    b.forEach(function (el, k) {
        b[k] = (~el >>> 0).toString(16);
    });

    while (c && c.length > 1) {
        c.forEach(function (el, i, c) {
            if (el && c[i + 1]) {
                c[i] = (el + c[i + 1]) / 2;
            } else { c.pop(); }
        });
    }
    alert([a, b, c]);
</script>
Der Aufruf von a.forEach() macht aus dem a-Array den Array [660,670,680]
Der Aufruf von b.forEach() macht aus dem b-Array den Array [ffffffff,fffffffe,fffffffd]
Der Aufruf von c.forEach() macht aus dem c-Array in den Schritten
c = [  1.0,  2.0,  3.0,  14.0 ]
c = [  1.5,  2.5,  8.5 ]
c = [  2.0,  5.5 ]
c = [  3.75 ]
den Array [3.75]
Die Funkton init_matrix(n) erzeugt und initialisiert eine quadratische 2D-Matrix mit n x n Zahlen. Richtige Aussage bitte ankreuzen.
<script>
function init_matrix(n) { 
  var i, j, a = [ ];
  for(i = 0; i < n; i += 1) { a[i] = [ ];
    for(j = 0; j < n; j += 1) {
      if (i + j +1 >= n) { a[i][j] = 10*i+j;
      } else             { a[i][j] = 0; }
    }
  } return a; 
}
</script>
Der Aufruf var v0 = init_matrix(3)[0] liefert den Vektor v0 = [0, 0, 2]
Der Aufruf var v2 = init_matrix(3)[2] liefert den Vektor v2 = [20, 21, 22]
Der Aufruf var arr = init_matrix(3) liefert die 3x3-Matrix mit den folgenden arr[i][j]-Elementen
arr[0][0]= 0;  arr[0][1]= 0;  arr[0][2]= 2;

arr[1][0]= 0;  arr[1][1]=11;  arr[1][2]=12;

arr[2][0]=20;  arr[2][1]=21;  arr[2][2]=22;
Der Array arr hat 4 Elemente arr[i]. In das Array-Element r[i] wird arr[i] + 10 "gepushed". Welchen Wert und Typ haben dann die r[i]-Elemente? Richtige Aussage bitte ankreuzen.
<script>
var arr = [ true, undefined, 'ABC', 4711 ];
var i, h, r = [ ];
for( i = 0; i < arr.length; i += 1 ) {  h = arr[i] + 10;
     r.push( h + ' mit typeof=' + typeof h );
}
</script>
Der r[0]-String ist "11 mit typeof=number"
Der r[1]-String ist "NaN mit typeof=number"
Der r[2]-String ist "ABC10 mit typeof=string"
Der r[3]-String ist "4721 mit typeof=number"
Auf den Array arr wird elementweise zugegriffen. Die angegebene String-Verkettung liefert einen Satz. Welchen? Bitte richtige Aussage ankreuzen.
<script>
var arr = [ [ '-', "auf " ], "Array", 'Elemente', 'Zugriff ' ];
alert( arr[3] + arr[0][1] + arr[1] + arr[0][0] + arr[2] );
</script>
Angezeigt wird der String "auf Array-Elemente Zugriff "
Angezeigt wird der String "Elemente-Zugriff auf Array"
Angezeigt wird der String "Zugriff auf Array-Elemente"
Bei ECMAScript ist this ein Schlüsselwort. Hier geht es um das folgende Code-Schnipsel und den Kontext, an den this gebunden wird. Bitte richtige Aussage ankreuzen.
<script>
var arr = [
  function () { return this.join('\n'); },
  function (that) { return function () { return that; }; } (this),
  function (i) { return this[i]; },
  function () { return this.length; },
  4711
];

alert(

arr[0](),arr[1](),arr[1],arr[2](4),arr[3]()oO0.join('\n')
); 
</script>
Der Aufruf arr[0]() liefert function () { return this.join('\n'); }
function () { return that; }
function (i) {return this[i]; }
function () {return this.length; }
4711
Der Aufruf arr[1]() liefert [object Window]
Der Aufruf arr[1] liefert function () { return that; }
Der Aufruf arr[2](4) liefert 4711 ( Wert des Array-Elementes arr[4) )
Der Aufruf arr[3]() liefert 5 ( arr.length ),
Es geht um die Schreibweisen von Objekt-Elementen. Die folgende Funktion obj_from_key_val_arr(key, val) macht elementweise aus den key-Array-Elementen und den zugehörigen val-Array-Elementen ein Objekt und gibt dieses zurück. Richtige Antworten bitte ankreuzen.
<script>
function obj_from_key_val_arr(key, val) { var i, o = {};
 for (i = 0; i < key.length; i += 1) {
  if (typeof val !== 'undefined') { o[key[i]] = val[i]; }
 } return o;
}

var obj = obj_from_key_val_arr(
['a', 'b', '0', ''], ['A', 0, '0', 4711]
          );
</script>
alert( obj['a'] ) zeigt den String "A" an.
alert( (obj['b'] === obj.b) ) zeigt true an.
alert( obj['0'] ) zeigt die Zahl 0 an.
alert( obj[''] ) zeigt die Zahl 4711 an.
Die bereits verfügbaren ( eingebauten ) Array-Funktion sollen um die folgende "selfmade-Funktion" arr.loop(fn) erweitert werden. arr.loop(fn) gibt einen ein neuer Array zurück. fn ist eine user-callback-function(el, i) { tu was mit dem i-ten Array-Element }.
<script>
if (!Function.prototype.method) { /* 1 */
     Function.prototype.method = function (func_name, func) {
       if (!this.prototype[func_name]) { 
            this.prototype[func_name] = func; 
       }
     };
}
Array.method('loop', function (fn) { /* 2 */
  var i, arr = this, r = [];
  for ( i = 0; i < arr.length; i += 1 ) { 
    r.push( fn.call( arr, arr[i], i ));
  } return r;
});

var sum = 0, /* 3 berechne r1, r2, r3, r4, r5 */
 r1 = [10,11,12].loop( function (el, i){return el + 10;}),
 r2 = [10,11,12].loop( function (el, i){return 20 + this[i];}),
 r3 = [10,11,12,13 ].loop( function (el, i) { var a = this; 
       switch(i){ // a[i] entspricht el
       case 0: return 23 + a[1]; 
       case 1: return 24 + a[0]; 
       case 2: delete a[2]; return a[0]+a[1]+a[3];
       default: return el*el - 135; 
       } 
 }),
 r4 = [10, 11, 12].loop(function (el, i) { sum += el; 
       if(i + 1 === this.length ){ return sum; }
 }),
 r5 = Array.prototype.loop.call("ABC", function(c) { 
      return c.charCodeAt(0); 
 }); </script>
Zum Definieren von quasie-eingebauten ECMAScript-Funktionen wird bei /* 1 */ (einmalig) der Name "method" als Function.prototype.method eingeführt.
Bei /* 2 */ wird zu den eingebauten Array-Funktionen eine "selfmade-Funktion" arr.loop(fn) als quasie-eingebaute Array-Funktion hinzu gefügt.
Die Berechnung bei /* 3 */ ergibt den Array r1 = [20,21,22]
Die Berechnung bei /* 3 */ ergibt den Array r2 = [30,31,32]
Die Berechnung bei /* 3 */ ergibt den Array r3 = [34,34,34,34]
Die Berechnung bei /* 3 */ ergibt den Array r4 = [33]
Die Berechnung bei /* 3 */ ergibt den Array r5 = [65,66,67]