Rangées de Javascript

Share

|

Puisque les objets sont des collections de propriétés avec chaque propriété ayant son propres nom et valeur, les rangées sont réellement des objets de Javascript. Chaque propriété dans une rangée est un élément, et chaque élément peut être assigné une valeur. L'one-way à penser à une rangée est comme collection de variables numérotées.

Une rangée dans le Javascript a les formats généraux suivants pour assigner des valeurs aux éléments :

sampleArr [0] =1 ; 
sampleArr [1] = " crème glacée " ; 
sampleArr [2] =55 * (7 + alpha) ; 
sampleArr [3] = shootTheMoon (73) ; 
sampleArr [4] = otherArr [7] ;  

ou

rangée de sampleArr=new (1, « crème glacée », (55 * (alpha 7+)), shootTheMoon (73), 
otherArr [17]) ;  

ou, dans Javascript 1.2 ou plus tard :

sampleArr= [1, « crème glacée », (55 * (alpha 7+)), shootTheMoon (73), otherArr [17]] ;  

Chacune des trois rangées est identique, suivre différentes méthodes pour la tâche de données. Les deux deuxièmes méthodes montrent que la rangée était plus d'un objet, alors que la première méthode montre variable-comme des caractéristiques des rangées.

Dans le Javascript, les éléments de tableau commencent par 0 et peuvent être numérotés séquentiellement ou non séquentiel. Dans les deux deuxièmes exemples précédents, le premier élément est 0, et les autres données séparées par des virgules sont numérotées séquentiellement. Cependant, vous pourriez avoir la tâche suivante de données dans une rangée :

alphaArr [0] = la « ONU » ; 
alphaArr [7] = « DOS » ; 
alphaArr [345] = « tres » ;  

Habituellement, des rangées sont numérotées séquentiellement de sorte que des données puissent être ajoutées et extraites utilisant des boucles. Cependant, un élément de tableau peut s'appeler en avant dans n'importe quel ordre et être employé juste comme une variable.

Les données et les types de données qui peuvent être assignés à un élément de tableau sont identiques aux données et aux types de données que vous pouvez assigner aux variables. Vous constaterez également que vous pouvez assigner à des objets les mêmes genres de données. (Rappelez-vous qu'une rangée est un objet parce qu'elle se compose pour plus qu'une propriété simple.)

Installation d'une rangée

Des rangées sont créées utilisant un constructeur, juste comme d'autres objets. Le constructeur de rangée () emploie le format suivant :

la variété partie = nouvelle rangée () ;

Maintenant, les pièces est un objet de rangée, et vous pouvez ajouter des données comme dans le format suivant :

les parties [0] = « se boulonne » ; 
parties [1] = « écrous » ;  

Comme avec déclarer une variable, vous n'avez pas besoin de saisir des données en déclarant la rangée, mais vous pouvez. Par exemple, vous pouvez déclarer et définir une rangée dense utilisant le constructeur de rangée () :

la variété partie = nouvelle rangée (« boulons », « écrous », « rondelles », « vis ») ;  

Vous pouvez également créer une rangée utilisant un argument de dimension. Si vous connaissez en avant du temps combien d'éléments sont dans votre rangée, vous pouvez la déclarer et placer une dimension pour elle en même temps. (Dans quelques langues, particulièrement les plus anciennes, vous êtes requis d'inclure une dimension pour qu'une rangée réserve la mémoire pour votre rangée.) Par exemple, si vous créez un choix du sénat des États-Unis et vous savez que vous avez seulement 100 sénateurs, vous pourriez déclarer et dimensionner votre rangée comme suit :

rangée de senators= de variété nouvelle (100) ;  

Une fois qu'avoué et dimensionné, vous pouvez ajouter 100 éléments, mais le premier sénateur soyez ceci :

sénateurs [0]  

Le bout serait ceci :

sénateurs [99]  

Vous obtenez toujours 100 éléments, mais vous devez commencer par 0 au lieu de 1.

La déclaration utilisant un argument de dimension est l'exception à la règle que la première valeur de données dans une rangée dense (une dans laquelle les données sont contenues entre parenthèses) est considérée l'élément 0. L'élément 0 dans la rangée sera la première tâche de données après la déclaration. Par exemple, la déclaration suivante première dimensionne la rangée à 5 et puis écrit le premier élément de tableau (0) en tant que 7 dans la prochaine ligne :

rangée de catWeights= de variété nouvelle (5) ; 
catWeights (7.15.34.52.60) ;  

La valeur de données numériques 5 n'est pas une valeur des éléments de tableau l'uns des. C'est la longueur de la rangée, avec des éléments s'étendant de 0-4.

NOTE

J'emploie le language= " Javascript " de <script d'étiquette > sans spécifier le nombre de version de Javascript. Vous n'avez pas besoin de spécifier le nombre de version pour obtenir la dernière version du Javascript soutenue par votre navigateur. Quand en utilisant un argument de dimension avec Netscape Navigator 4 (NN4) et plus tard, vous rencontrerez par hasard un bogue si vous spécifiez le language= de <script " JavaScript1.2 " > et essayent alors de dimensionner une rangée. NN4+ traite la déclaration avec la valeur de dimension comme la première valeur dans la rangée au lieu de la longueur de la rangée. Par exemple, essayez le manuscrit suivant :

<html> 
<head> 
language= " JavaScript1.2 " de <script > 
rangée de test= de variété nouvelle (23) 
document.write (test.length) ; 
</script> 
</head> 
<body> 
</body> 
</html>

Quand vous courez le manuscrit utilisant NN4 ou plus tard, un 1 apparaît sur l'écran. Si vous enlevez l'attribut 1.2 de l'étiquette de <script>, la valeur retournée est 23, la longueur correcte. Puisque le Javascript 1.5 court juste le dandy dans Netscape Navigator 6 sans spécifier le nombre de version dans l'étiquette de <script>, et la dernière version pour Internet Explorer fonctionne également bien sans spécifier le nombre de version, je préfère omettre tous les nombres de version comme habitude. De cette façon, je peux éviter des bogues et enjamber plus de versions de Javascript et de navigateur.

Une manière finale de déclarer une rangée utilisant le Javascript 1.2 ou plus tard s'appelle une coquille de rangée. La déclaration utilise des parenthèses au lieu des parenthèses et n'exige pas le constructeur de rangée (). Le nom d'objet de rangée est déclaré simplement en lui assignant des valeurs dans des parenthèses, car le manuscrit suivant montre :

<html> 
<head> 
language= " Javascript " de <script > 
variété Lit= [« oui », « pas », « peut-être »] ; 
document.write (Lit [2]) ; 
</script> 
</head> 
bgcolor=#face00> <body 
</body> 
</html>

Les sembler littéraux de Lit de rangée comme presque une définition variable, si elle n'étaient pas pour la liste encadrée de valeurs. Utilisant une coquille de rangée sauve deux ou trois étapes parce qu'aucun constructeur n'est employé, mais des navigateurs plus âgés (ceux avant appui de Javascript 1.2) ne le comprendront pas comme rangée.

Propriétés et méthodes de rangée

Comme objet, les rangées ont une propriété simple, la longueur, et plusieurs méthodes. Cependant, Netscape Navigator 4 a présenté cinq méthodes, Array.pop (), Array.push (), ift d'Array.sh (), Array.unshift (), et Array.splice (), qui ne sont pas soutenus par Internet Explorer ou la norme EMCA-262. Pour éviter des problèmes mais être inclus, j'ai placé les méthodes de rangée de NN4+ dans une section pour vous alerter au fait que les utilisateurs de l'IE ne les analyseront pas correctement. Comme tous les perfectionnements de Javascript non soutenus par les normes d'EMCA, je ne recommande pas d'employer ces méthodes pour la création des sites Web qui comptent avoir des visionneuses utilisant les deux navigateurs importants.

Longueur de rangée

La longueur simple de propriété de rangée renvoie le nombre d'éléments dans une rangée. En employant une boucle, la condition d'essai pour la boucle peut être la longueur de la rangée de sorte que vous n'ayez pas besoin d'employer une valeur invariable pour l'essai. Le format est comme suit :

Array.length

La propriété est facilement passée à une variable, car l'échantillon suivant montre :

la variété poursuit = nouvelle rangée (« briquet », « terrier », « colley », « chien ») ; 
dogTail= dogs.length de variété ;  

Le dogTail variable aurait une longueur de 4 parce que quatre éléments composent la rangée. La propriété de longueur ne se rapporte pas au nombre de caractères qui composent l'élément dans la rangée, mais elle se rapporte au nombre d'éléments eux-mêmes. Ainsi, la rangée suivante a une longueur de 2, quoique plus de caractères soient employés que dans le premier exemple avec une longueur de 4 :

la variété poursuit = nouvelle rangée (un « plus grand chien suisse de montagne », « un Wolfhound irlandais ») ;

Concaténation des éléments d'une rangée : joignez (), toString (), et le concat ()

La méthode d'Array.join () prend toutes les valeurs dans tous les éléments dans la rangée et crée une grande corde. Par exemple, essayez le manuscrit suivant :

joinArray.html

<html> 
<head> 
language= " Javascript " de <script > 
rangée de trees= de variété nouvelle (« orme », « pin », « chêne ») ; 
variété bigBush=trees.join () ; 
document.write (bigBush) ; 
</script> 
</head> 
bgcolor=#ace007> <body 
</body> 
</html>

Les résultats sont le contenu de la rangée sans les guillemets, te montrant l'orme, pin, chêne.

La méthode d'Array.join () accepte un argument qui agit en tant que séparateur. Celui que vous placiez dans les parenthèses de jointure () dans des guillemets remplace les virgules. Par exemple, changez cette ligne :

variété bigBush=trees.join () ;  

à

variété bigBush=trees.join (« et ") ;  

Puis, lancez le manuscrit encore pour un résultat différent. Les deuxièmes résultats sont orme et pin et chêne.

Une méthode plus ancienne du Javascript 1.1 qui est semblable à la méthode d'Array.join () est Array.toString (). () La méthode toString produit des mêmes résultats que se joignent (), mais vous ne pouvez pas spécifier les caractères se reliants entre les éléments comme vous pouvez avec se joindre ().

Une troisième méthode employée pour enchaîner des éléments de corde dans les rangées est Array.concat (). Non seulement la méthode de concat () joint-elle tous les éléments existants, mais elle ajoute également les éléments dans un argument de concat (). Par exemple, en changeant le manuscrit de joinArray.html légèrement, vous pouvez voir comment cela fonctionne.

concatArray.html

<html> 
<head> 
language= " Javascript " de <script > 
rangée de trees= de variété nouvelle (« orme », « pin », « chêne ») ; 
variété biggerBush=trees.concat (« érable », « sycomore ») ; 
variété bigBush=trees.join () ; 
document.write (biggerBush) ; 
alerte (bigBush) ; 
</script> 
</head> 
bgcolor=#ace007> <body 
</body> 
</html>

Très une part importante du manuscrit de concatArray.html est que vous pouvez voir que la méthode d'Array.concat () ne change pas le contenu de la rangée. La rangée appelée des arbres a toujours seulement trois éléments. Cela est démontré par le fait que le message alerte montre seulement trois éléments, quoique le bigBush variable ait été défini après la variable de biggerBush ait été défini et ait ajouté les données d'érable et de sycomore au mélange. Pour ajouter des éléments à une rangée, vous assignez de nouvelles valeurs aux éléments appelés. Par exemple, pour inclure les données d'érable et de sycomore à la rangée, vous pourriez écrire ceci :

arbres [3] = " érable " ; // le quatrième élément est 3 puisque le premier est 0 
arbres [4] = " sycomore " ;

Changement de l'ordre d'une rangée : sorte () et inverse ()

Deux méthodes sont disponibles pour changer l'ordre des éléments de tableau. Le premier classe les éléments de corde de rangée par ordre alphabétique, et le deuxième renverse leur ordre.

La méthode d'Array.sort () est très simple, particulièrement en employant des cordes. Après avoir présenté toutes les cordes dans la rangée, vous écrivez juste le nom de la rangée et de la méthode, et la rangée est commandée alphabétiquement. L'exemple suivant montre comment la méthode de sorte () fonctionne et comment des éléments de tableau sont extraits au moyen un rapport de boucle.

sortArray.html

<html> 
<head> 
language= " Javascript " de <script > 
rangée de zoo= de variété nouvelle (« zèbres », « lions », « singes », « tigres ») ; 
zoo.sort () ; 
"" de newZoo= de variété ; 
pour (variété counter=0 ; counter<zoo.length ; counter++) {
newZoo += (zoo [contre-] + « <br>") ; 
} 
document.write (« Animals<p> <p>Alphabetical » + newZoo) ; 
</script> 
</head> 
bgcolor= <body " lightsteelblue " > 
</body> 
</html>

Toutes les valeurs sont arrangées dans l'ordre alphabétique.

singes

lions

tigres

zèbres

Pour les listes de commande de sorte, vous trouverez la méthode d'Array.sort () un outil maniable.

La méthode d'Array.reverse () renverse simplement l'ordre des données dans la rangée. Le premier élément devient le dernier élément, et tout autrement dans la rangée est aussi bien renversé. Par exemple, ce qui suit :

rangée de majorCities=new de variété (« Tokyo », « Los Angeles », « Paris », « Pékin », « Bloomfield ») 
marjorCities.reverse () ;  

renverrait ceci :

Bloomfield, Pékin, Paris, Los Angeles, Tokyo

En employant Array.sort () et Array.reverse () de concert, vous pouvez changer des ordres décroissants croissants et d'une liste assortie.

Extraction de Subarrays : tranche ()

Pour spécifier un subarray, employez Array.slice (). La forme générale d'employer la tranche () est montrée ici :

ArrayName.slice (commencez, extrémité)  

ou

ArrayName.slice (commencez à finir)  

Par exemple, si vous avez ces rapports :

computer= [« Dell », « passage », « Apple », « IBM », « HP »] ; 
computer.slice (2.4) ;  

votre retour serait

Apple, IBM

Utilisant un argument simple prend l'élément de l'argument à la fin de la rangée comme définie par l'argument. Par exemple :

computer.slice (2) ;  

retournerait

Apple, IBM, HP,

Les nombres négatifs constituent un type final d'argument utilisé dans la méthode d'Array.slice (). La valeur négative commence par le dernier élément dans la rangée comme -1 et puis compte vers l'arrière vers le premier élément. Par exemple, le rapport de l'exemple dans cette section :

computer.slice (- 1)  

renvoie ceci :

HP

À la différence des tranches de vers l'avant-compte qui commencent par 0, le dernier élément dans une rangée est identifié pendant que -1 suivre la méthode de tranche () avec une rangée.

Méthodes de matrice de tores du navigateur 4 : sautez (), poussez (), décalage (), unshift (), l'épissure ()

Cet dernier ensemble de méthodes ajoute beaucoup d'utilité au travail avec des rangées, et vous pouvez exécuter empiler-comme des opérations avec la rangée. Si vous avez jamais écrit des programmes dedans en avant ou le code écrit pour le post-scriptum d'Adobe, vous avez travaillé avec la pile, et sautez () et la poussée () sont familière. Chacun des cinq est décrit brièvement avec une explication courte et est basé sur l'exemple simple suivant :

rangée de stackWork= de variété nouvelle (« Lenny », « Harold », « Mary », « Jean », « sel ») ;

Array.pop () enlève le dernier élément d'une rangée et le renvoie.

stackWork.pop () ; le sel de retours et l'enlève de la rangée. Si un deuxième rapport identique étaient faits sur la prochaine ligne, il retournerait Jean.

Array.push () ajoute une valeur à l'extrémité de la rangée (dessus de la pile) et des feuilles il là. En ajoutant la ligne suivante, la corde Delia deviendrait la valeur à un nouveau dernier élément supplémentaire à la rangée par la méthode de poussée () :

stackWork.push (« Delia ») ;  

Dans une opération de bruit (), il serait éteint le premier (LIFO-dernier dedans, d'abord au loin).

l'ift d'Array.sh () enlève le premier élément dans une rangée et le renvoie. Par exemple, ceci renverrait Lenny, l'enlèverait de la rangée, et décalerait les éléments restants vers la gauche :

ift de stackWork.sh () ;  

L'élément 0 irait bien à Harold.

Array.unshift () est semblable à la méthode de poussée (), sauf qu'au nouvel élément est mis à l'avant de la rangée (le fond de la pile). Si vous entriez dans le suivant, le premier élément (élément 0) dans la rangée aurait une valeur de Willie, la valeur Lenny serait décalé vers la droite dans l'élément 1, et ainsi de suite pour la rangée entière :

stackWork.unshift (« Willie ») ;  

En conclusion, Array.splice () est une méthode employée pour insérer, supprimer, et substituer des valeurs dans des éléments de tableau. La méthode a trois arguments, débuts, suppressions, et données. La position de départ spécifie où la nouvelle valeur (données) doit être insérée et où les suppressions commencent. Si aucune suppression n'est spécifiée, la méthode d'épissure () a l'effet d'insérer un élément et une valeur dans une rangée. Par exemple, les expositions suivantes comment insérer la valeur Fred dans le deuxième élément, laissant le premier en tant que lui est et décalant le repos vers la droite :

stackWork.splice (1.0, « Fred ») ;  

La méthode d'épissure () te permet d'insérer des éléments, de supprimer un ou plusieurs éléments, ou de changer la valeur d'un élément de tableau. Vous pourriez constater que ces fonctions ne fonctionnent pas dans certains des navigateurs plus âgés, mais IE5+ et NN4+ fonctionnent bien avec eux.