Perché La Matematica.min() > per la Matematica.max()?

Quando tipo in un array il parametro di javascript di matematica di massimo e minimo di funzioni, restituisce il valore corretto:

console.log( Math.min( 5 ) ); //5
console.log( Math.max( 2 ) ); //2

var array = [3, 6, 1, 5, 0, -2, 3];
var minArray = Math.min( array ); //-2
var maxArray = Math.max( array ); //6

Tuttavia, quando uso la funzione senza parametri, restituisce una risposta errata:

console.log( Math.min() ); //Infinity
console.log( Math.max() ); //-Infinity

Questo restituisce false:

console.log( Math.min() < Math.max() );

Perché fa questo?

  • Che browser stai? Math.min/max non funziona su array.
  • Chrome versione: 16.0.912.75 m
  • anche a me, sono sicuro che hai -2 e 6? Essi dovrebbero essere NaN
  • Non è davvero il “fronte” di risposta.
  • Premendo F12 e la valutazione della ” Matematica.min( 5 ) ” non ritorno 5, non NaN.
  • perché chiamare Math.Min o Math.Max senza parametri?
  • Non so. Ma sembrava più ragionevole che Math.min() sarebbe pari a -Infinity, e Math.max() sarebbe pari a Infinity
  • Perché valutare Math.min( 5 ) quando ho parlato Array, -2 e 6 😮 Math.min( [3, 6, 1, 5, 0, -2, 3]) dovrebbe tornare NaN e non -2.
  • Hanno un occhiata a wtfjs.com, primo elemento.
  • Stai rizzano come “il valore minimo di un numero qualsiasi”, quando in realtà è ancora “il valore minimo degli argomenti”.
  • Lasciate che questa conoscenza .apply essere nelle risposte. L’OP non sapevo su di esso, in modo che la modifica in questione non è valido.
  • Penso che l’OP uso e si applica per ottenere quei risultati, non c’è modo correva il codice letteralmente e ottenuto -2 e 6. Ho provato a chiedere a lui su di esso nei commenti, ma non rispose.
  • Io non credo che si dovrebbe fare un’ipotesi. Se l’OP lo conferma poi si può modificare.

InformationsquelleAutor user824294 | 2012-01-13

 

10 Replies
  1. 45

    Naturalmente, perché il numero di partenza dovrebbe essere Infinity per Math.min. Tutti i numeri sono inferiori a infinito positivo dovrebbe essere il più piccolo dalla lista, se non ci sono più piccoli.

    E per Math.max è lo stesso; tutti i numeri che sono più grandi di infinito negativo dovrebbe essere il più grande se non ci sono grandi.

    Così, per il vostro primo esempio:

    Math.min(5) dove 5 è minore di infinito (Infinity) tornerà 5.

    Aggiornamento

    Chiamata Math.min() e Math.max con parametro un array non può funzionare su qualsiasi piattaforma. Si dovrebbe fare invece la seguente:

    Math.min.apply(null, [ 1, 2, 3, 4 , 5 ]);

    Dove il primo parametro è l’ambito in argomento. Perché Math.min() e Math.max() sono “statici” funzioni, dobbiamo impostare la portata argomento è null.

    • Rende perfettamente l’idea
    • Questo è un perfetto esempio di intelligente di sicurezza sconsiderato designer considerando la teoria più importante di usabilità. Capisco perché stai suggerendo di questo concetto di “numero di partenza” sano di mente o anche corretto, ma a mio parere, che l’algoritmo di implementazione di perdite nei risultati. In nessun modo è immediatamente evidente a chiunque si avvicina la lingua al momento della lettura Math.min() come una riga di codice, l’ultima cosa che mi aspetterei che il ritorno è Infinito (il numero massimo possibile). Apprezzo il JS, ma mi piacerebbe mettere questo esattamente nel “deplorevole decisioni” di categoria.
    • e perché non sei d’accordo con il disegno che si downvote la mia risposta. Bello!
    • Io non downvote perché sono in disaccordo con il design, in realtà ho con voto positivo la risposta qui sotto che dice la stessa cosa, ma va più nel dettaglio. Hai la mia downvote solo perché “naturalmente…”.
  2. 31

    È difficile, ma importante, per decidere correttamente ciò che funzioni di aggregazione dovrebbe fare quando passò l’insieme vuoto.

    A volte è ‘intuitivamente ovvia”: Qual è la SOMMA di n elementi? Zero, sono sicuro che tutti sarebbero facilmente dire.

    A volte è da meno: che Cosa è il PRODOTTO di n elementi? Con alcuni matematici di formazione sarà presto a dire “uno”, ma questo non è affatto ovvio.

    Poi si arriva a MIN e MAX e wow! Come siamo arrivati quelli infiniti?


    Un modo per decidere che una funzione di aggregazione dovrebbe fare è prendere in considerazione comportamenti che noi vogliamo rimanere coerenti, anche con set vuoti. Per esempio, supponiamo di avere questi insiemi non vuoti:

    A = { 1, 2, 3 } 
    B = { 4, 5 }

    Ora, è vero che qui, e in effetti per qualsiasi insiemi non vuoti, che

    SUM(A union B) = SUM(SUM(A), SUM(B))
    15 = 6 + 9
    
    PRODUCT(A union B) = PRODUCT(PRODUCT(A), PRODUCT(B))
    120 = 6 * 20
    
    MIN(A union B) = MIN(MIN(A), MIN(B))
    1 = MIN(1, 4)

    Non sarebbe bello, dicono i matematici, se queste proprietà rimane vero anche quando uno o entrambi i set sono vuoti? Sicuramente sarebbe.

    E maintainint questo comportamento che decide quale sia il valore assegnare a SOME_AGGREGATE_FUNCTION(empty-set) :

    In ordine per

    SUM(A union B) = SUM(SUM(A), SUM(B))

    di rimanere fedeli quando A è vuoto e B non è, dobbiamo avere SUM(empty-set) = 0

    In ordine per

    PRODUCT(A union B) = PRODUCT(PRODUCT(A), PRODUCT(B))

    di rimanere fedeli quando A è vuoto e B non è, dobbiamo avere PRODUCT(empty-set) = 1

    E infine:

    In ordine per

    MIN(A union B) = MIN(MIN(A), MIN(B))

    di rimanere fedeli quando A è vuoto e B non è, abbiamo bisogno di MIN(empty-set) essere un valore che è garantito per essere più grande di ogni possibile valore in B, in modo che non interferisca con’ il risultato di MIN(B). E abbiamo la nostra risposta: MIN(empty-set) = positive infinity

  3. 19

    Perché fa questo?

    Perché questo è ciò che lo standard dice dovrebbe accadere;

    15.8.2.11 max ( [ valore1 [ , valore2 [ , … ] ] ] )

    Data zero o più argomenti, chiamate ToNumber su ciascuno degli argomenti e restituisce il più grande dei valori risultanti.

    • Se non ci sono argomenti, il risultato è -Infinito
    • Se qualsiasi valore NaN, il risultato è un NaN.
    • Il confronto di valori per determinare il valore più grande è il fatto, come in 11.8.5 tranne che +0 è considerato di essere più grande di 0.

    15.8.2.12 min ( [ valore1 [ , valore2 [ , … ] ] ] )

    Data zero o più argomenti, chiamate ToNumber su tutti gli argomenti e restituisce il più piccolo dei valori risultanti.

    • Se non ci sono argomenti, il risultato è Infinito.
    • Se qualsiasi valore NaN, il risultato è un NaN.
    • Il confronto di valori per determinare il valore più piccolo è fatto, come in 11.8.5 tranne che +0 è considerato
      per essere più grande di 0

    p.s; è non standard che Math.max() o Math.min() accetta un array. Utilizzare Math.max(a,b,c,d,e,...) ecc invece.

    In Chrome almeno;

    Math.max([1,2,3,4]); //NaN
    • Dannazione, mi ha battuto. Principalmente perché ho trascorso più tempo formattazione ;P
    • Questa è la “logica” per la definizione di min e max per vuoto della serie, ma forse non il buon senso 😉
  4. 14

    È lo stesso motivo per cui la somma di una lista vuota è di solito definito come 0 e il loro prodotto come 1: è l’elemento di identità dell’operazione. Che è, ogni volta che si includono -Infinito come un elemento quando computing max, non influenza il risultato, rispettivamente per l’Infinito e min.

    Questo è ragionevole, perché permette di desiderabile “associativo” proprietà per le operazioni di aggregazione. Per esempio, la somma di un elenco è lo stesso come il calcolo di somme di qualsiasi sottoliste (forse comprese quelle vuote) e sommarli. Allo stesso modo per i prodotti, minuti, maxes e così via.

    • Penso che hai detto è meglio.
  5. 10

    [ECMA-262: 15.8.2.11]: max ( [ value1 [ , value2 [ , ... ] ] ] )

    Data zero o più argomenti, chiamate ToNumber su ciascuno degli argomenti e restituisce il più grande dei valori risultanti.

    • Se non ci sono argomenti, il risultato è −∞.
    • Se qualche valore è NaN, il risultato è NaN.
    • Il confronto di valori per determinare il valore più grande è il fatto, come in 11.8.5 tranne che +0 è considerato di essere più grande di -0.

    Il length proprietà del max metodo 2.

    [ECMA-262: 15.8.2.12]: min ( [ value1 [ , value2 [ , ... ] ] ] )

    Data zero o più argomenti, chiamate ToNumber su tutti gli argomenti e restituisce il più piccolo dei valori risultanti.

    • Se non ci sono argomenti, il risultato è +∞.
    • Se qualche valore è NaN, il risultato è NaN.
    • Il confronto di valori per determinare il valore più piccolo è fatto, come in 11.8.5 tranne che +0 è considerato di essere più grande di -0.

    Il length proprietà del min metodo 2.

    Senza argomenti, Math.min è un valore che è possibile utilizzare per calcolare il iterativo minimo, non fisico, valore minimo per il tipo. Si fa essendo l’opposto: un fisico valore massimo per il tipo. (Allo stesso modo in un’altra direzione, per Math.max; e chiaramente +∞ < -∞ è false.)

    cioè

    var a = [1,2,3,4,5];
    var x = Math.min();
    for (var i = 0; i < a.length; i++) {
        if (a[i] < x) { //will succeed on first iteration
                        //because `x` is initialised to highest possible value
           x = a[i];
        }
    }

    (In realtà, è può semplicemente essere che la norma è fare l’attuazione di Math.min più facile, dato che probabilmente inizializza il suo risultato a +Infinito prima di fare il suo lavoro su qualsiasi argomento attuale, utilizzando un algoritmo simile a quello sopra.)

    Naturalmente, questo esempio è leggermente forzato dal momento che si potrebbe scrivere:

     var x = Math.min(a[0], a[1], a[2], a[3], a[4]);

    Tuttavia, il ciclo è utile se non si conosce il numero di elementi nell’array, in quanto la variante di Math.min stai usando che accetta un array non è standard.

    Anche allora, si può fare:

     var x = Math.min.apply(null, a);
     //              ^ reflective function-call
     //                    ^ no object instance; function is "static"
     //                          ^ array of arguments
  6. 7

    Probabilmente perché l’implementazione inizializza un confronto interno variabile per il massimo (per la Matematica.min) o più basso (per la Matematica.max), prima di iniziare a confrontare con l’array vuoto, e quindi restituisce il valore di questo confronto interno variabile che, naturalmente, non è stato modificato.

    • Io non sono sicuro di capire.
    • Oh, ora ho capito. Non si tratta di semplice attuazione, però: questo risultato è definito dallo standard.
  7. 3

    Non so per certo. Ma, solo una congettura.

    Ricordo come si trova il min. Dichiarare una variabile con un valore estremamente elevato (Infinito) e poi passare attraverso i valori e ogni volta che si trova un valore che è inferiore a quello memorizzato nella variabile, lo store, invece, il nuovo min.

    Così, perché non dare alcun valore a trovare il minimo per, ti dà il valore iniziale, cioè l’Infinito.

    Stesso per max.

  8. 0

    Quando somministrato senza argomenti, Math.min() è uguale a infinito e Math.max() è -infinity.

    Questo è probabilmente quello di garantire che ogni valore è inferiore al valore minimo trovato finora, e superiore al limite massimo finora.

    • Penso che la sua domanda è stata perché è così? Non dovrebbe essere stato il contrario?
  9. 0

    L’idea è, matematicamente, senza alcun parametro in realtà hanno un valore non definito per il minimo.

    Per l’attuazione saggio, di solito, il valore minimo è inizializzato con un valore molto elevato(Infinito), che viene quindi aggiornato i valori inferiori sono trovato. Se il valore non viene trovato, allora avete Infinity come il valore min.

    Caso è opposto con trovare il valore massimo e che è il motivo per cui si dispone di -Infinity .

  10. 0

    Teoricamente l’esito di tali funzioni è non può essere data. Ecma specifica determina l’esito di funzioni Min e Max senza argomenti (Vedere a pagina 163).

    Ovviamente si può avere ogni sorta di argomenti su ciò che il risultato dovrebbe essere, ma non c’è una strettamente risposta corretta comunque. Credo che Ecma scegliere questo perché è il più facile da implementare. Normalmente una funzione max funziona all’incirca come questo

    result = -infinity;
    foreach(arg in arguments)
        if(arg > result)
            result = arg;

    Come si può vedere, di ritorno -infinito quando viene chiamata la funzione senza argomenti non richiede alcuna modifica a tutti.

Lascia un commento