Erläuterung der Tipps für Array-Arrays in JavaScript

Dieser Artikel stellt hauptsächlich die Tipps zu Array-Arrays in JavaScript vor. Jetzt kann ich ihn mit Ihnen teilen

1.

Objekte wie Arrays verwenden:

var obj = {
    length: 0,

    addElem: function addElem (elem) {
        // obj.length is automatically incremented 
        // every time an element is added.
        [].push.call(this, elem);
    }
};

// Let's add some empty objects just to illustrate.
obj.addElem({});
obj.addElem({});
console.log(obj.length);
// → 2

Obwohl obj kein Array ist, lässt die Push-Methode die Längeneigenschaft von obj erfolgreich wachsen, genau wie wir es mit einem tatsächlichen Array tun würden.

2. Array.prototype.sort()

arr.sort(compareFunction)

Parameter: compareFunction
Optional. Wird verwendet, um Funktionen anzugeben, die in einer bestimmten Reihenfolge angeordnet sind. Wenn es weggelassen wird, werden die Elemente nach der Unicode-Position jedes Zeichens der Zeichenfolge sortiert, in die konvertiert wird.

Wenn compareFunction angegeben ist, wird das Array nach dem Rückgabewert des Funktionsaufrufs sortiert. Das heißt, a und b sind zwei zu vergleichende Elemente:

• Wenn compareFunction(a, b) kleiner als 0 ist, wird a vor b angeordnet; >

  Wenn
gleich 0 ist, bleiben die relativen Positionen von a und b unverändert.

• compareFunction(a, b)

  Wenn
größer als 0 ist, wird b vor a angeordnet .

• compareFunction(a, b)

  Das Format der Vergleichsfunktion ist wie folgt (sowohl Strings als auch Arrays können verglichen werden):

function compare(a, b) {
    if (a < b ) {           // 按某种排序标准进行比较, a 小于 b
        return -1;
    }
    if (a > b ) {
        return 1;
    }
    // a must be equal to b
    return 0;
}

3. Array.prototype.unshift()

var arr = [1, 2];
arr.unshift(-2, -1);    // = 5
// arr is [-2, -1, 1, 2]

4 . Array.prototype.concat()

gibt ein neues Array zurück (

flache Kopie

), ohne das ursprüngliche Array zu beeinflussen.

Wenn der Parameter ein Array ist, fügen Sie die Elemente des Arrays in das Ergebnis ein.

• Wenn der Parameter kein Array ist, fügen Sie ein der Parameter selbst. Die Ergebnisse werden ausgeführt.

• var num1 = [1, 2, 3],
      num2 = [4, 5, 6],
      num3 = [7, 8, 9];
  
  var nums = num1.concat(num2, num3);
  
  console.log(nums); 
  // results in [1, 2, 3, 4, 5, 6, 7, 8, 9];
  
  var alpha = ['a', 'b', 'c'];
  
  var alphaNumeric = alpha.concat(1, [2, 3]);
  
  console.log(alphaNumeric); 
  // results in ['a', 'b', 'c', 1, 2, 3]

  5. Array.prototype.forEach()

array.forEach(callback(currentValue, index, array){
    //do something
}, thisArg)

array.forEach(callback[, thisArg])

wobei:

ein optionaler Parameter ist, der als

beim Ausführen des Callback-Funktionswerts verwendet wird (Referenzobjekt).

thisArgDie folgenden Funktionen verfügen außerdem über den optionalen Parameter this und die Verwendung stimmt mit

überein:

thisArgArray.prototype.forEach()

Array.prototype.forEach()

• Array.prototype.every()

• Array.prototype.some()

• Array.prototype .filter()

• Array.prototype.map()

• Array.prototype.reduce()

• Array.prototype.reduceRight()

• 6. Array.prototype.map()

Anwendungstipps Fall

// 下面的语句返回什么呢:
["1", "2", "3"].map(parseInt);
// 你可能觉的会是[1, 2, 3]
// 但实际的结果是 [1, NaN, NaN]

// 通常使用parseInt时,只需要传递一个参数.
// 但实际上,parseInt可以有两个参数.第二个参数是进制数.
// 可以通过语句"alert(parseInt.length)===2"来验证.
// map方法在调用callback函数时,会给它传递三个参数:当前正在遍历的元素, 
// 元素索引, 原数组本身.
// 第三个参数parseInt会忽视, 但第二个参数不会,也就是说,
// parseInt把传过来的索引值当成进制数来使用.从而返回了NaN.

function returnInt(element) {
  return parseInt(element, 10);
}

['1', '2', '3'].map(returnInt); // [1, 2, 3]
// 意料之中的结果

// 也可以使用简单的箭头函数，结果同上
['1', '2', '3'].map( str => parseInt(str) );

// 一个更简单的方式:
['1', '2', '3'].map(Number); // [1, 2, 3]
// 与`parseInt` 不同，下面的结果会返回浮点数或指数:
['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300]

7. Array.prototype.reduction()

arr.reduce(callback[, initialValue]) ähnelt seiner Verwendung und verläuft von rechts nach links.

Parameter: Array.prototype.reduceRight()

: Eine Funktion, die jeden Wert im Array ausführt und vier Parameter enthält:

• callback

: Der Akkumulator akkumuliert den Rückgabewert des Rückrufs; es handelt sich um den akkumulierten Wert, der beim letzten Aufruf des Rückrufs zurückgegeben wurde, oder
• (wie unten gezeigt).

  accumulatorinitialValue

: Das Element, das im Array verarbeitet wird.

• currentValue

: Optional, der Index des aktuellen Elements, das im Array verarbeitet wird. Wenn initialValue angegeben wird, ist die Indexnummer 0, andernfalls ist der Index 1.

• currentIndex

: Optional, Aufruf des Arrays von
• .

  arrayreduce

: Optional, wird als Wert des ersten Parameters des ersten Rückrufaufrufs verwendet. Wenn kein Anfangswert angegeben wird, wird das erste Element im Array verwendet. Der Aufruf von
• für ein leeres Array ohne Anfangswert führt zu einem Fehler.

  initialValuereduce

  So funktioniert das Reduzieren eines Arrays

[0, 1, 2, 3, 4].reduce(function(accumulator, currentValue, currentIndex, array){
  return accumulator + currentValue;
}, 10);

// 20

im Objektarray. Beispiel: Array-Deduplizierung

var flattened = [[0, 1], [2, 3], [4, 5]].reduce(
  function(a, b) {
    return a.concat(b);
  },
  []
);
// flattened is [0, 1, 2, 3, 4, 5]

Das Obige ist hoffentlich der gesamte Inhalt dieses Artikels Es wird für das Lernen aller hilfreich sein. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website!

Verwandte Empfehlungen:

So verwenden Sie die Angular-UI Bootstrap-Komponente zum Implementieren von Warnungen

So implementieren Sie einen Stack mit JavaScript

Das obige ist der detaillierte Inhalt vonErläuterung der Tipps für Array-Arrays in JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!