Le tableau n'a pas de méthode d'index, il est donc plus difficile de trouver l'index d'un élément dans un tableau. Afin de faciliter les appels, Array.prototype.Indexof () est étendu via le prototype prototype, qui est plus pratique à utiliser. Cependant, cet index personnalisé a des problèmes lorsqu'il traversait le tableau.
La copie de code est la suivante:
Array.prototype.indexof = fonction (item) {
for (var i = 0; i <this.length; i ++) {
if (this [i] == item)
retour i;
}
retour -1;
}
Lorsque vous l'utilisez, c'est simple
La copie de code est la suivante:
var arr = [1,2,3,4,5];
var index = arr.indexof (1); // index == 0
Après l'expansion, il est très rafraîchissant et pratique à utiliser, et c'est une scène harmonieuse ...
Mais quand une fois itère sur les éléments du tableau, en utilisant le pour..in. La boucle a causé d'autres problèmes et a brisé l'atmosphère harmonieuse.
La copie de code est la suivante:
var a = ["zhang fei", "guan yu", "liu bei", "lu bu"];
pour (var p dans a) {
document.write (p + "=" + a [p] + "<br/>");
}
Je voulais à l'origine sortir les noms de ces quatre personnes, mais quel était le résultat?
La sortie est en fait:
La copie de code est la suivante:
// 0 = Zhang Fei
// 1 = Guan Yu
// 2 = Liu Bei
// 3 = lu bu
// indexof = function (item) {for (var i = 0; i <this.length; i ++) {if (this [i] == item) return i; } return -1; }
En plus de taper le nom, il publie également son propre index de méthode étendu, mais ce qui est fou, c'est que Firefox est "normal", avec seulement quatre noms de personnes. Pourquoi cela se produit-il?
L'indice de sortie, qui est étendu par lui-même, peut être compris. Après tout, pour..in est d'itérer à travers toutes les propriétés définies par l'utilisateur d'un objet ou de tous les éléments d'un tableau.
Alors pourquoi ne Firefox?
Après avoir vérifié les informations, j'ai réalisé que
Array prend déjà en charge Array.Indexof () dans la version JavaScript 1.6, tandis que le Firefox que j'utilise est la version 3.5, qui prend déjà en charge JavaScript 1.8. L'indexof est une méthode inhérente de tableau lui-même.
Quant à IE, même si j'utilise IE8, il ne prend en charge que la version JavaScript 1.3.
Par conséquent, IE8 estime que l'indexof est un "attribut défini par l'utilisateur", tandis que Firefox estime qu'il s'agit d'un attribut inhérent pris en charge par son propre support natif.
Est-ce vraiment le cas?
Faites une expérience, modifiez l'index de MyIndexof et réessayez. En conséquence, IE et Firefox Sortie MyIndexof, prouvant que le point précédent est correct.
Puis une autre question vient. Je suis élargi l'indexof depuis longtemps. Maintenant, de nombreux codes de projet utilisent cette méthode. Maintenant, je dois utiliser pour ... en production d'éléments du tableau lui-même. Ne l'étendez pas moi-même à la méthode russe. Que dois-je faire?
Heureusement, JavaScript fournit la méthode HasownProperty.
Jetez un œil à sa description:
La copie de code est la suivante:
Chaque objet descend de l'objet hérite de la méthode HasownProperty. Cette méthode peut être utilisée pour déterminer si un objet a la propriété spécifiée en tant que propriété directe de cet objet; Contrairement à l'opérateur in, cette méthode ne vérifie pas la chaîne prototype de l'objet
À en juger par la description, c'est ce que nous voulons.
Faites juste un jugement pour ... dans ...
La copie de code est la suivante:
if (a.hasownproperty (p)) {
document.write (p + "=" + a [p] + "<br/>");
}
De plus, un exemple d'utilisation de HasownProperty est attaché, qui vient d'Internet:
La copie de code est la suivante:
Livre de fonction (titre, auteur) {
this.title = title;
this.author = auteur;
}
Book.prototype.price = 9,99;
Object.prototype.copyright = "hheongyang.com";
var mybook = nouveau livre ("tutoriels javascript", "Herong Yang");
// vidange des propriétés intégrées au niveau du prototype de base
Document.Writeln ("/ nobject.prototype Propriétés intégrées:");
DUMPPROPERTY (object.prototype, "constructeur");
DUMPPROPERTY (objet.prototype, "HasownProperty");
DUMPPROPERTY (objet.prototype, "isPrototypeOf");
DUMPPROPERTY (object.prototype, "toString");
DUMPPROPERTY (object.prototype, "ValueOf");
DUMPPROPERTY (object.prototype, "Copyright");
// Déchargement des propriétés intégrées au niveau de mon prototype
Document.Writeln ("/ n ===================== / NBOOK.Prototype Propriétés intégrées:");
DUMPPROPERTY (livre.prototype, "constructeur");
DUMPPROPERTY (livre.prototype, "HasownProperty");
DUMPPROPERTY (livre.prototype, "isprototypeof");
DUMPPROPERTY (livre.prototype, "tostring");
DUMPPROPERTY (livre.prototype, "Value");
DUMPPROPERTY (livre.prototype, "Copyright");
// Jetez des propriétés intégrées au niveau de l'objet
Document.Writeln ("/ n ===================== / NMYBOOK INTRAPOST PROPRIÉTÉS:");
DUMPPROPERTY (MyBook, "Constructor");
DUMPPROPERTY (MyBook, "HasownProperty");
DUMPPROPERTY (MyBook, "isPrototypeOf");
DUMPPROPERTY (MyBook, "Tostring");
DUMPPROPERTY (MyBook, "ValueOf");
DUMPPROPERTY (MyBook, "Copyright");
fonction dumpproperty (objet, propriété) {
Héritage var;
if (object.hasownproperty (propriété))
héritage = "local";
autre
héritage = "héritage";
document.writeln (propriété + ":" + héritage + ":"
+ objet [propriété]);
}
Vérifiez quelle version de JavaScript est prise en charge par le navigateur:
La copie de code est la suivante:
<! Doctype html public "- // w3c // dtd xhtml 1.0 transitional // en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<adal>
<meta http-equiv = "contenu-type" contenu = "text / html; charset = utf-8" />
<Title> La version JavaScript du navigateur prend en charge les tests </Title>
</ head>
<body>
<script linguisse = "javascript">
//Document.write(" votre type de navigateur: "+ navigator.appname +" <br/> ");
//Document.write("browser version: "+ navigator.appversion +" <br/> ");
// Les navigateurs prennent en charge JavaScript 1.0 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.0 <br/>');
</cript>
<script linguisse = "javascript1.1">
// Les navigateurs prennent en charge JavaScript 1.1 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.1 <br/>');
</cript>
<script linguisse = "javascript1.2">
// Les navigateurs prennent en charge JavaScript 1.2 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.2 <br/>');
</cript>
<script linguisse = "javascript1.3">
// Les navigateurs prennent en charge JavaScript 1.3 peut exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.3 <br/>');
</cript>
<script linguisse = "javascript1.4">
// Les navigateurs prennent en charge JavaScript 1.4 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.4 <br/>');
</cript>
<script linguisse = "javascript1.5">
// Les navigateurs prennent en charge JavaScript 1.5 peut exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.5 <br/>');
</cript>
<script linguisse = "javascript1.6">
// Les navigateurs prennent en charge JavaScript 1.6 peut exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.6 <br/>');
</cript>
<script linguisse = "javascript1.7">
// Les navigateurs prennent en charge JavaScript 1.7 peut exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.7 <br/>');
</cript>
<script linguisse = "javascript1.8">
// Les navigateurs prennent en charge JavaScript 1.8 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.8 <br/>');
</cript>
<script linguisse = "javascript1.9">
// Les navigateurs prennent en charge JavaScript 1.9 peuvent exécuter ce script
Document.Write ('Ce navigateur prend en charge JavaScript1.9 <br/>');
</cript>
</docy>
</html>