Pourquoi ne ++[[]][+[]]+[+[]] de retour de la chaîne “10”?

C'est valide et renvoie la chaîne "10" en JavaScript (d'autres exemples ici):

JS:

console.log(++[[]][+[]]+[+[]])

Pourquoi? Ce qui se passe ici?

  • Commencer par comprendre que +[] jette un tableau vide à 0... puis les déchets d'un après-midi... 😉
  • Connexes stackoverflow.com/questions/4170978/explain-why-this-works .
  • Jetez un oeil à wtfjs.com - elle a pas mal de choses comme ça avec explanatinos.
  • où voulez-vous apprendre ce genre de choses? Quels livres? J'apprends le JS de la SOCIÉTÉ et ils n'enseignent pas ces choses
  • De la même manière que vous venez de faire: quelqu'un a posté à ce sujet quelque part et il m'est arrivé de le lire.
  • Ces arent vraiment des choses que vous devriez utiliser dans la programmation normale. C'est juste un caprice de canard-typage et la conversion implicite. Vous avez probablement vu que vous pouvez utiliser ! pour transformer un nombre en une valeur de type boolean. Vous pouvez utiliser + à son tour un booléen ou une chaîne en un nombre. À partir de là, tout ce que vous devez comprendre est que les valeurs de retour truthy (contraindre à true ou 1) et les valeurs de retour falsey (contraindre à false ou 0)

InformationsquelleAutor |
  1. 1992

    Si nous diviser, le carré est égal à:

    ++[[]][+[]]
+
[+[]]

    En JavaScript, il est vrai que +[] === 0. + convertit quelque chose dans un certain nombre, et dans ce cas, il sera de +"" ou 0 (voir la spécification des détails ci-dessous).

    Par conséquent, nous pouvons le simplifier (++ a precendence sur +):

    ++[[]][0]
+
[0]

    Parce que [[]][0] signifie: obtenir le premier élément de [[]], il est vrai que:

    • [[]][0] renvoie l'intérieur array ([]). En raison de références, il est faux de dire [[]][0] === [], mais nous allons appeler l'intérieur de la matrice de A pour éviter la mauvaise notation.
    • ++[[]][0] == A + 1, depuis ++ signifie "incrément par un".
    • ++[[]][0] === +(A + 1); en d'autres termes, il sera toujours un nombre (+1 ne renvoie pas nécessairement à un nombre, alors que ++ le fait toujours - grâce à Tim vers le Bas pour le signaler).

    Encore une fois, nous pouvons simplifier le désordre dans quelque chose de plus lisible. Nous allons remplacer [] de retour pour A:

    +([] + 1)
+
[0]

    En JavaScript, c'est vrai: [] + 1 === "1", parce que [] == "" (joindre un tableau vide), donc:

    • +([] + 1) === +("" + 1), et
    • +("" + 1) === +("1"), et
    • +("1") === 1

    Nous allons simplifier encore plus:

    1
+
[0]

    Aussi, c'est vrai qu'en JavaScript: [0] == "0", parce que c'est rejoindre un tableau avec un seul élément. Joindre à concaténer les éléments séparés par des ,. Avec un seul élément, vous pouvez en déduire que cette logique du premier élément lui-même.

    Donc, à la fin, nous obtenons (nombre + string = string):

    1
+
"0"

=== "10" //Yay!

    Des spécifications détaillées pour +[]:

    C'est un labyrinthe, mais de faire +[], d'abord, il est converti en chaîne, car c'est ce que + dit:

    11.4.6 Unaire + Opérateur

    Unaire + opérateur convertit son opérande de type de Numéro.

    La production UnaryExpression : + UnaryExpression est évaluée comme suit:

    1. Laisser expr être le résultat de l'évaluation UnaryExpression.

    2. Retour ToNumber(GetValue(expr)).

    ToNumber() dit:

    Objet

    Appliquer les étapes suivantes:

    1. Laisser primValue être ToPrimitive(argument d'entrée, un soupçon de Chaîne).

    2. Retour ToString(primValue).

    ToPrimitive() dit:

    Objet

    Retourner une valeur par défaut pour l'Objet. La valeur par défaut d'un objet est extrait par l'appel de la [[Valeur par défaut]] méthode interne de l'objet, en passant l'option soupçon PreferredType. Le comportement de la [[Valeur par défaut]] méthode interne est défini par cette spécification pour tous les natifs ECMAScript objets dans 8.12.8.

    [[DefaultValue]] dit:

    8.12.8 [[Valeur par défaut]] (hint)

    Lors de la [[Valeur par défaut]] méthode interne de O est appelée avec indicateur de Chaîne, les mesures suivantes sont prises:

    1. Laisser toString être le résultat de l'appel de la [[Get]] méthode interne de l'objet O avec l'argument "toString".

    2. Si IsCallable(toString) est vrai, alors,

    un. Laissez-str être le résultat de l'appel de la [[Appel]] interne méthode toString, avec O comme cette valeur et une liste d'arguments vide.

    b. Si str est une valeur primitive, retour str.

    La .toString d'un tableau dit:

    15.4.4.2 Tableau.le prototype.toString ( )

    Lorsque la méthode toString est appelée, les mesures suivantes sont prises:

    1. Laisser matrice être le résultat de l'appel ToObject sur la valeur de this.

    2. Laisser func être le résultat de l'appel de la [[Get]] méthode interne de la matrice avec l'argument "rejoindre".

    3. Si IsCallable(func) est faux, alors laissez func être le standard intégré dans la méthode Objet.le prototype.toString (15.2.4.2).

    4. Retourner le résultat de l'appel de la [[Appel]] méthode interne de func fournissant tableau en tant que cette valeur et un argument vide de la liste.

    Donc +[] revient à +"", parce que [].join() === "".

    Encore une fois, la + est défini comme:

    11.4.6 Unaire + Opérateur

    Unaire + opérateur convertit son opérande de type de Numéro.

    La production UnaryExpression : + UnaryExpression est évaluée comme suit:

    1. Laisser expr être le résultat de l'évaluation UnaryExpression.

    2. Retour ToNumber(GetValue(expr)).

    ToNumber est défini pour "" comme:

    Le MV de StringNumericLiteral ::: [vide] est 0.

    Donc +"" === 0, et donc +[] === 0.

    • comment allez-vous de ++[[]][0] à [] + 1?
    • Ryan: [[]][0] est que imbriquée []. ++ incréments de avec un, il retourne [] + 1.
    • Suggestion: faire de la "++[[]][0] à [] + 1" transformation explicite dans le post. Cela rend la chose beaucoup plus compréhensible pour ceux d'entre nous qui ne connais pas le JavaScript!
    • Je sais = pour l'affectation et l' == pour comparaison. Qu'est-ce que ===?
    • C'est la stricte égalité checker, c'est à dire qu'il ne retourne true si à la fois la valeur et de la nature sont les mêmes. 0 == "" retourne true (même après la conversion de type), mais 0 === "" est false (pas les mêmes types).
    • Une partie de ce n'est pas correct. L'expression se résume à 1 + [0], pas "1" + [0], parce que le préfixe (++) opérateur renvoie toujours un nombre. Voir bclary.com/2004/11/07/#a-11.4.4
    • En bas: Vous êtes tout à fait correct. Je suis en train de corriger cela, mais lorsque j'essaie de le faire, j'ai trouvé quelque chose d'autre. Je ne suis pas sûr de savoir comment cela est possible. ++[[]][0] renvoie en effet 1, mais ++[] renvoie une erreur. Ce qui est remarquable, parce qu'il ressemble à ++[[]][0] ne se résument ++[]. Avez-vous peut-être une idée de pourquoi ++[] déclenche une erreur alors que ++[[]][0] ne l'est pas?
    • Je suis sûr que le problème est dans la PutValue appel (ES3 terminologie, 8.7.2) dans le préfixe de l'opération. PutValue requiert une Référence alors que [] comme une expression de sa propre ne produit pas une Référence. Une expression contenant une référence à une variable (disons nous avions défini précédemment var a = [] puis ++a travaux) ou l'accès à la propriété d'un objet (comme [[]][0]) produit de Référence. En termes plus simples, le préfixe de l'opérateur non seulement produit une valeur, elle a également besoin d'un endroit pour mettre cette valeur.
    • Ainsi, après l'exécution de var a = []; ++a, a est 1. Après l'exécution de ++[[]][0], le tableau créé par le [[]] expression est maintenant contient juste le numéro 1 à l'indice 0. ++ requiert une Référence pour ce faire.
    • nit: Un instanceof Array (comme []) sera jamais === un Array autres que lui-même, comme l'Opérateur de Comparaison Stricte compare simplement lref à rref (c'est à dire les emplacements de mémoire de chaque instance). Je ne recommanderais pas ce qui implique même ce. Vous pouvez également noter dans votre réponse que JS' Unaire + Opérateur a la préséance sur le résultat d'une expression arithmétique résultat ou la concaténation de chaîne (selon le contexte) avec ++ ou + c'est pourquoi +[] obtient d'abord évaluée.
    • Faisceau: Très vrai, merci pour vos commentaires. (Comme une note de côté, l'abrégé de l'égalité de l'opérateur vérifie également pour les références; je viens de toujours utiliser l'opérateur d'égalité stricte pour éviter les caprices.)

    InformationsquelleAutor pimvdb
  2. 118
    ++[[]][+[]] => 1 //[+[]] = [0], ++0 = 1
[+[]] => [0]

    Ensuite, nous avons une concaténation de chaîne

    1+[0].toString() = 10
    • Ne serait-il pas plus clair d'écrire === plutôt que =>?
    InformationsquelleAutor Shef
  3. 59

    Ce qui suit est adapté à partir d'un post de blog de répondre à cette question que j'ai posté alors que cette question était encore fermé. Les liens sont à (HTML copie de) la ECMAScript 3 spec, toujours la référence pour JavaScript aujourd'hui couramment utilisé des navigateurs web.

    Tout d'abord, un commentaire: ce genre d'expression ne va jamais à faire (sane) environnement de production et n'a d'utilité que comme un exercice de la façon dont le lecteur connaît la sale bords de JavaScript. Le principe général que les opérateurs JavaScript implicitement la conversion entre les types de est utile, comme le sont certains de la commune de conversions, mais beaucoup de détails dans ce cas, ne l'est pas.

    L'expression ++[[]][+[]]+[+[]] peut au premier abord sembler plutôt imposant et obscure, mais est en fait relativement facile de briser dans des expressions séparées. Ci-dessous, j'ai simplement ajouté entre parenthèses pour plus de clarté, je peux vous assurer qu'ils ne changent rien, mais si vous voulez vérifier que alors n'hésitez pas à lire les groupement de l'opérateur. Ainsi, l'expression peut être écrite plus clairement que

    ( ++[[]][+[]] ) + ( [+[]] )

    Faire, nous pouvons simplifier en observant que +[] évalue à 0. Pour satisfaire vous-même pourquoi c'est vrai, consultez le unaire + opérateur et suivez les légèrement tortueux sentier qui se termine avec ToPrimitive convertir le vide d'un tableau dans une chaîne vide, ce qui est finalement converti à 0 par ToNumber. Nous pouvons maintenant remplacer 0 pour chaque instance de +[]:

    ( ++[[]][0] ) + [0]

    Plus simple déjà. Comme pour ++[[]][0], qui est une combinaison de la préfixe opérateur d'incrémentation (++), un littéral de tableau la définition d'un tableau à un seul élément qui est lui-même un tableau vide ([[]]) et un propriété de l'accesseur ([0]) a appelé la matrice définie par le littéral de tableau.

    Donc, nous pouvons simplifier [[]][0] juste [] et nous avons ++[], droit? En fait, ce n'est pas le cas, car l'évaluation de ++[] renvoie une erreur, ce qui peut paraître déroutant. Cependant, un peu de réflexion sur la nature de ++ est clair à ce sujet: il est utilisé pour incrémenter une variable (par exemple,++i) ou une propriété de l'objet (par exemple,++obj.count). Non seulement il s'évaluer à une valeur, il stocke également que la valeur de quelque part. Dans le cas de ++[], il n'a nulle part où mettre la nouvelle valeur (quelle qu'elle soit) parce qu'il n'y est fait aucune référence à une propriété de l'objet ou variable de mise à jour. Dans spec termes, cela est couvert par l'interne PutValue opération, qui est appelée par le préfixe de l'opérateur d'incrémentation.

    Alors, ce n' ++[[]][0] faire? Eh bien, par la même logique que +[], à l'intérieur de la matrice est converti à 0 et cette valeur est incrémentée par 1 pour nous donner une valeur finale de 1. La valeur de la propriété 0 à l'extérieur tableau est mis à jour pour 1 et l'ensemble de l'expression est évaluée à 1.

    Ce qui nous laisse avec

    1 + [0]

    ... qui est une simple utilisation de la opérateur d'addition. Les deux opérandes sont d'abord converti primitives et si une primitive de la valeur est une chaîne, la concaténation de chaîne est exécutée, sinon addition est effectuée. [0] convertit à "0", de sorte que la concaténation de chaîne est utilisé, la production de "10".

    Comme une finale de côté, quelque chose qui peut ne pas être immédiatement apparent est primordial, soit l'un des toString() ou valueOf() méthodes de Array.prototype va changer le résultat de l'expression, parce que les deux sont contrôlés et utilisés s'il est présent lors de la conversion d'un objet en une valeur primitive. Par exemple, la suite

    Array.prototype.toString = function() {
  return "foo";
};
++[[]][+[]]+[+[]]

    ... produit "NaNfoo". Pourquoi cela se produit est laissé comme exercice pour le lecteur...

    InformationsquelleAutor Tim Down
  4. 23

    Nous allons faire simple:

    ++[[]][+[]]+[+[]] = "10"

var a = [[]][+[]];
var b = [+[]];

//so a == [] and b == [0]

++a;

//then a == 1 and b is still that array [0]
//when you sum the var a and an array, it will sum b as a string just like that:

1 + "0" = "10"
    InformationsquelleAutor renatoluna
  5. 13

    Ce que l'on évalue de la même mais un peu plus petit

    +!![]+''+(+[])
    • [] est un tableau est converti converti à 0 lorsque vous ajoutez ou soustrayez il, donc +[] = 0
    • ![] - a la valeur false, donc !![] évalue à true
    • +!![] - convertit la vraie valeur numérique qui prend la valeur true, alors dans ce cas, 1
    • +" - ajoute une chaîne vide à l'expression provoquant le nombre à convertir en chaîne de
    • +[] - donne 0

    est donc évalue à

    +(true) + '' + (0)
1 + '' + 0
"10"

    Alors maintenant, vous l'avez compris, essayez celui-ci:

    _=$=+[],++_+''+$
    • quelle est la réponse? '010' ?
    • Et bien non, encore évalue à "10". Toutefois, c'est de le faire d'une manière différente. Essayez d'évaluer ce dans un javascript inspecteur de chrome ou de quelque chose.
    • _=$=+[],++_+"+$ -> _=$=0,++_+"+$ -> _=0,$=0,++_+"+$ -> ++0+"+0 -> 1+"+0 -> '10' // Yei :v
    InformationsquelleAutor Vlad Shlosberg
  6. 7

    +[] prend la valeur 0
    [...] ensuite somme (+ fonctionnement) avec quoi que ce soit convertit tableau contenu de sa représentation sous forme de chaîne composée des éléments rejoint par des virgules.

    Autre chose comme prendre de l'indice du tableau (ont râpe prioritaire que l'opération+) est ordinale et ne trouve rien d'intéressant.

    InformationsquelleAutor Eskat0n
  7. 4

    Peut-être la plus courte possible, des moyens pour évaluer une expression en "10" sans chiffres sont les suivants:

    +!+[] + [+[]] //"10"

    -~[] + [+[]] //"10"

    //========== Explication ==========\\

    +!+[] : +[] Convertit à 0. !0 convertit à true. +true convertit à 1.
    -~[] = -(-1) qui est de 1

    [+[]] : +[] Convertit à 0. [0] est un tableau à un seul élément 0.

    Puis JS évalue la 1 + [0], ainsi Number + Array expression. Puis la spécification ECMA travaux: + opérateur convertit les deux opérandes d'une chaîne en appelant le toString()/valueOf() fonctions à partir de la base Object prototype. Il fonctionne comme un additif de la fonction si les deux opérandes d'une expression sont que des chiffres. Le truc, c'est que les piles de convertir facilement leurs éléments dans une chaîne concaténée représentation.

    Quelques exemples:

    1 + {} //   "1[object Object]"
1 + [] //   "1"
1 + new Date() //   "1Wed Jun 19 2013 12:13:25 GMT+0400 (Caucasus Standard Time)"

    Il y a une belle exception de deux Objects plus de résultats dans NaN:

    [] + []   //   ""
[1] + [2] //   "12"
{} + {}   //   NaN
{a:1} + {b:2}     //   NaN
[1, {}] + [2, {}] //   "1,[object Object]2,[object Object]"
    InformationsquelleAutor
  8. 1
    1. Unaire de plus, compte tenu de la chaîne convertie en nombre
    2. Opérateur d'incrémentation chaîne convertit et s'incrémente de 1
    3. [] == ". Chaîne Vide

    4. +" ou " + [] évalue 0.

      ++[[]][+[]]+[+[]] = 10 
++[''][0] + [0] : First part is gives zeroth element of the array which is empty string 
1+0 
10
    • La réponse est confuse/confus, OIE mal. [] est pas équivalent à "". D'abord l'élément est extrait, puis converti par ++.
    InformationsquelleAutor Praveen Vedanth
  9. 0

    Étape par étapes de l', + son tour de la valeur à un nombre et si vous ajoutez à un tableau vide +[]...comme c'est vide et est égale à 0, il

    Donc à partir de là, maintenant, regardez dans votre code, il est ++[[]][+[]]+[+[]]...

    Et il n'y a plus entre eux ++[[]][+[]] + [+[]]

    De sorte que ces [+[]] sera de retour [0] comme ils ont un tableau vide qui est converti à 0 à l'intérieur de l'autre tableau...

    De sorte que l'imaginer, la première valeur est un 2 dimensions tableau avec un tableau à l'intérieur... donc [[]][+[]] sera égal à [[]][0] qui sera de retour []...

    Et à la fin ++ le convertir et l'augmenter pour 1...

    De sorte que vous pouvez l'imaginer, 1 + "0" sera "10"...

    Pourquoi ne ++[[]][+[]]+[+[]] de retour de la chaîne “10”?

    InformationsquelleAutor