A matriz não possui um método de índice, por isso é mais problemático encontrar o índice de um elemento em uma matriz. Para facilitar a chamada, Array.prototype.IndexOF () é estendido através do protótipo protótipo, que é mais conveniente de usar. No entanto, esse índice personalizado tem problemas ao atravessar a matriz.
A cópia do código é a seguinte:
Array.prototype.indexOF = function (item) {
for (var i = 0; i <this.length; i ++) {
if (este [i] == item)
retornar i;
}
retornar -1;
}
Ao usá -lo, é direto
A cópia do código é a seguinte:
var arr = [1,2,3,4,5];
var index = arr.IndexOF (1); // index == 0
Após a expansão, é muito refrescante e conveniente de usar, e é uma cena harmoniosa ...
Mas quando uma vez itera sobre os elementos da matriz, usando o para ... O loop causou outros problemas e quebrou a atmosfera harmoniosa.
A cópia do código é a seguinte:
var a = ["Zhang Fei", "Guan Yu", "Liu Bei", "Lu Bu"];
para (var p em a) {
document.write (p+"="+a [p]+"<br/>");
}
Originalmente, eu queria produzir os nomes dessas quatro pessoas, mas qual foi o resultado?
A saída é realmente:
A cópia do código é a seguinte:
// 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; } retornar -1; }
Além de digitar o nome, ele também gera seu próprio método estendido indexOF, mas o que é louco é que o Firefox é "normal", com apenas quatro nomes de pessoas. Por que isso está acontecendo?
O índice de saída, que é estendido por si só, pode ser entendido. Afinal, para ... é iterar em todas as propriedades definidas pelo usuário de um objeto ou em todos os elementos de uma matriz.
Então, por que o Firefox não?
Depois de verificar as informações, percebi que
O Array já suporta Array.IndexOF () na versão JavaScript 1.6, enquanto o Firefox que eu uso é a versão 3.5, que já suporta JavaScript 1.8. IndexOf é um método inerente de matriz.
Quanto ao IE, mesmo se eu usar o IE8, ele suporta apenas a versão JavaScript 1.3.
Portanto, o IE8 acredita que o IndexOF é um "atributo definido pelo usuário", enquanto o Firefox acredita que é um atributo inerente suportado por seu próprio suporte nativo.
Esse é realmente o caso?
Faça um experimento, altere o indexOF para MyIndexOF e tente novamente. Como resultado, o IE e a saída do Firefox MyIndexof, provando que o ponto anterior está correto.
Então outra pergunta vem. Eu expandi o indexOF há muito tempo. Agora, muitos códigos de projeto estão usando esse método. Agora eu tenho que usar para produzir elementos da própria matriz. Não estenda -o ao método russo sozinho. O que devo fazer?
Felizmente, o JavaScript fornece o método HasownProperty.
Dê uma olhada em sua descrição:
A cópia do código é a seguinte:
Todo objeto descendente de objeto herda o método HasownProperty. Este método pode ser usado para determinar se um objeto possui a propriedade especificada como uma propriedade direta desse objeto; Ao contrário do operador, esse método não verifica a cadeia de protótipo do objeto
A julgar pela descrição, é o que queremos.
Apenas faça um julgamento para ... em ...
A cópia do código é a seguinte:
if (A.HasownProperty (P)) {
document.write (p+"="+a [p]+"<br/>");
}
Além disso, é anexado um exemplo de uso do HASOWNPROPERTY, que vem da Internet:
A cópia do código é a seguinte:
Livro da função (título, autor) {
this.title = title;
this.author = autor;
}
Book.prototype.price = 9,99;
Object.prototype.copyright = "herongyang.com";
var myBook = novo livro ("Javascript Tutorials", "Herong Yang");
// despejar propriedades embutidas no nível do protótipo base
Document.Writeln ("/nobject.prototype Propriedades internas:");
dumpproperty (object.prototype, "construtor");
dumpproperty (object.prototype, "HasOwnsProperty");
dumpproperty (object.prototype, "isprototypeof");
dumpproperty (object.prototype, "ToString");
dumpproperty (object.prototype, "valueof");
dumpproperty (object.prototype, "direitos autorais");
// despejar propriedades embutidas no meu nível de protótipo
document.writeln ("/n ======================/nBook.Prototype Propriedades internas:");
dumpproperty (book.prototype, "construtor");
Dumproperty (Book.prototype, "HasownProperty");
dumproperty (book.prototype, "isprototypeof");
dumpproperty (book.prototype, "ToString");
dumpproperty (book.prototype, "valueof");
Dumproperty (Book.prototype, "Copyright");
// despejar propriedades embutidas no nível do objeto
Document.Writeln ("/n ======================/NMYbook Propriedades internas:");
Dumpproperty (MyBook, "Construtor");
Dumpproperty (MyBook, "HasownProperty");
dumproperty (mybook, "isprototypeof");
Dumpproperty (MyBook, "ToString");
dumpproperty (mybook, "valueof");
Dumproperty (MyBook, "Copyright");
função dumpproperty (objeto, propriedade) {
herança var;
if (object.HasownProperty (Propriedade))
herança = "local";
outro
herança = "herança";
Document.Writeln (Propriedade+":"+Herança+":"
+objeto [propriedade]);
}
Verifique qual versão do JavaScript é suportada pelo navegador:
A cópia do código é a seguinte:
<! Doctype html public "-// w3c // dtd xhtml 1.0 transitional // pt" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-bransitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv = "content-type" content = "text /html; charset = utf-8" />
<title> A versão JavaScript do navegador suporta testes </ititle>
</head>
<Body>
<Script Language = "JavaScript">
//document.write("your navegador tipo: "+navegator.appname+" <br/> ");
//document.write("Browser Versão: "+Navigator.AppVersion+" <br/> ");
// navegadores que suportam o JavaScript 1.0 podem executar este script
Document.Write ('Este navegador suporta javascript1.0 <br/>');
</script>
<Script Language = "JavaScript1.1">
// navegadores que suportam o JavaScript 1.1 podem executar este script
Document.Write ('Este navegador suporta javascript1.1 <br/>');
</script>
<Script Language = "JavaScript1.2">
// navegadores que suportam o JavaScript 1.2 podem executar este script
Document.Write ('Este navegador suporta javascript1.2 <br/>');
</script>
<Script Language = "JavaScript1.3">
// navegadores que suportam o JavaScript 1.3 podem executar este script
Document.Write ('Este navegador suporta javascript1.3 <br/>');
</script>
<Script Language = "JavaScript1.4">
// navegadores que suportam o JavaScript 1.4 podem executar este script
Document.Write ('Este navegador suporta javascript1.4 <br/>');
</script>
<Script Language = "JavaScript1.5">
// navegadores que suportam o JavaScript 1.5 podem executar este script
Document.Write ('Este navegador suporta javascript1.5 <br/>');
</script>
<Script Language = "JavaScript1.6">
// navegadores que suportam o JavaScript 1.6 podem executar este script
Document.Write ('Este navegador suporta javascript1.6 <br/>');
</script>
<Script Language = "JavaScript1.7">
// navegadores que suportam o JavaScript 1.7 podem executar este script
Document.Write ('Este navegador suporta javascript1.7 <br/>');
</script>
<Script Language = "JavaScript1.8">
// navegadores que suportam o JavaScript 1.8 podem executar este script
Document.Write ('Este navegador suporta javascript1.8 <br/>');
</script>
<Script Language = "JavaScript1.9">
// navegadores que suportam o JavaScript 1.9 podem executar este script
Document.Write ('Este navegador suporta JavaScript1.9 <br/>');
</script>
</body>
</html>