Können wir `const` anstelle von` let` überall verwenden?

Question

Mit flowtype bevorzugen wir const gegen let

I Funktion haben, die in den meisten performante Art und Weise gearbeitet werden muss, und es funktioniert gut für mich, es zwei Arrays vergleichen ist, so ist es cool Beispiel für meine Frage:

/** 
* @function compare 
* @description function compares two arrays with ids to figure out: are they equal? (elements position can be different) 
* @param arraFrom {Array} 
* @param arraTo {Array} 
* @param compareFunction {Function} 
* @returns {Boolean} 
*/ 
function compare(arraFrom, arraTo, compareFunction) { 
    let notEqual = true; 
    if(arraFrom.length !== arraTo.length) return false; 
    for (let i = 0; i < arraFrom.length; i++) { 
     notEqual = true; 
     for (let j = 0; j < arraTo.length; j++) { 
     if (compareFunction ? 
      compareFunction(arraFrom[i], arraTo[j]) : 
      arraFrom[i] === arraTo[j]) { 
      notEqual = false; 
      break; 
     } 
     } 
     if (notEqual) return false; 
    } 
    return true; 
} 

Frage ist: wie können wir es implementieren, ohne let in der performantesten Weise zu verwenden?

Vielen Dank!

Answer 1

Statt die Anordnungen von Iterieren von Indexvariablen mutiert, können Sie for…of Loops verwenden:

function compare(arraFrom, arraTo, compareFunction) { 
    let notEqual = true; 
    if(arraFrom.length !== arraTo.length) return false; 
    for (const a of arraFrom) { 
    notEqual = true; 
    for (const b of arraTo) { 
     if (compareFunction ? compareFunction(a,b) : a === b) { 
     notEqual = false; 
     break; 
     } 
    } 
    if (notEqual) return false; 
    } 
    return true; 
} 

Statt dieser wandelbaren notEqual Flagge, können Sie einfach früh zurück:

function compare(arraFrom, arraTo, compareFunction) { 
    if (arraFrom.length !== arraTo.length) return false; 
    outer: for (const a of arraFrom) { 
    for (const b of arraTo) { 
     if (compareFunction ? compareFunction(a,b) : a === b) { 
     continue outer; 
     } 
    } 
    return false; 
    } 
    return true; 
} 

Aber das ist ziemlich unlesbar. Ich würde folgendes empfehlen:

function compare(arrayFrom, arrayTo, compareFunction) { 
    if (arrayFrom.length !== arrayTo.length) return false; 
    const test = typeof compareFunction == "function" 
    ? a => b => compareFunction(a, b) 
    : a => b => a === b; 
    return arrayFrom.every(a => arrayTo.some(test(a))); 
} 

Answer 2

Wenn Sie den Wert nicht ändern, können Sie ihn überall verwenden. Der Unterschied ist, dass Sie den Wert von const nicht ändern können. Es gibt keine anderen Unterschiede außer dieser

Answer 3

Warum genau bevorzugen Sie const über let? const hat die Eigenschaft, dass es sich nicht ändern lassen wird. Sie werden nicht bekommen und Fehler, wenn Sie versuchen, es zu ändern. Stattdessen wird es nur seinen ursprünglichen Wert behalten. Der von Ihnen gepostete Code hat absolut keinen Platz für const.