gruss Paul

ich habe ein array (dynamisch aus einer DB erzeugt). Darin stehen Zahlenwerte
mit Nachkommastellen. Nun muss ich die Kommas durch Punkte ersetzen. Dies kann
ich aber leider erst in JS machen, da die Daten vorher noch mit dem Komma als
Trennzeichen verarbeitet werden.

da ich mich anhand Deiner aufgabenstellung mal so richtig austoben moechte,
   bekommst Du von mir keinen loesungsansatz, sondern einen schon zusammen-
   gefuegten bastelsatz mit erklaerung.

wie schon mehrfach erwaehnt, handelt es sich bei den eintraegen Deines arrays
   keineswegs um zahlen sondern um "string"-werte - also ungefaehr so:

~~~javascript var arr = ["12,45", "9,525", "13,1", "7,15", "126,3", "37,8845", "21,965"];
   alert((arr.toSource) ? (arr.toSource()) : (arr));

  
   um die kommata wirklich schnell zu ersetzen, empfehle ich, von der [String]-  
   methode "replace" sowie von den [Array]-methoden "join" und "split" gebrauch  
   zu machen.  
  
   "join" fuegt alle eintraege Deines arrays zu einem grossen string. gibt man  
   dieser methode einen string-parameter mit auf den weg, wird dieser zwischen  
   den einzelnen arraywerten eingefuegt:  
  
   ~~~javascript
arr = arr.join("|");  
   alert((arr.toSource) ? (arr.toSource()) : (arr)); // eine lange zeichenkette;

"replace" wird unter zuhilfenahme eines einfachen regulaeren ausdrucks alle
   in der zeichenkette vorkommenden kommata durch einen punkt ersetzen:

~~~javascript arr = arr.replace((/,/g), ".");
   alert((arr.toSource) ? (arr.toSource()) : (arr)); // keine kommata mehr;

  
   zwischen den begrenzern des RegExp-literals steht das zu ersetzende zeichen.  
   hinter dem abschliessenden "/" ist das sogenannte "global-flag" gesetzt, das  
   der RegExp-maschine mitteilt, die suche nicht schon nach der ersten ueberein-  
   stimmung abzubrechen, sondern den vergleich auf das suchmuster bis zum ende  
   durchzuziehen.  
  
   "split" trennt die zeichenkette an genau dem muster, welches als argument  
   dieser methode mitgegeben wird, packt die so entstandenen teil-strings in  
   ein array und gibt dieses zurueck:  
  
   ~~~javascript
arr = arr.split("|"); // deswegen wurde die pipe schon bei "join" genommen;  
   alert((arr.toSource) ? (arr.toSource()) : (arr)); // keine kommata mehr;

das ganze kann man auch zusammenfassend auf eine zeile bringen:

~~~javascript var arr = ["12,45", "9,525", "13,1", "7,15", "126,3", "37,8845", "21,965"];
   arr = arr.join("|").replace((/,/g), ".").split("|");

  
   soweit, sogut. im array stehen aber immer noch string-werte und keine zahlen!  
  
   jetzt liesse sich das array durchlaufen und jeder wert koennte durch die  
   globale methode "parseFloat" gejagt werden:  
  
   ~~~javascript
for (var i=0; i<arr.length; ++i) {  
     arr[i] = Number(parseFloat(arr[i]));  
   }  
   alert((arr.toSource) ? (arr.toSource()) : (arr)); // nur noch zahlenwerte;

schoen - ABER:

seit Gecko 1.8b2 und JavaScript 1.6 nach mozilla.org stehen ein paar neue,
   von manchen lang herbeigesehnte, weil arbeitserleichternde [Array]-iteratoren
   zur vefuegung. und die methode "map" kommt hier wie gerufen:

arr = arr.map(function (elm, idx, arr) {return Number(parseFloat(elm));});

in der praxis muss aber nicht auf diese art zu entwickeln verzichtet werden,
   denn es gibt genau dafuer verschiedene JavaScript-bibliotheken, welche die
   neuen methoden auch den anderen browsern einpflanzen ...
   ... achtung eigenwerbung ... z.b. diese hier:

http://www.pseliger.de/jsExtendedApi/jsApi.Array.mozExtensions.dev.js
   http://www.pseliger.de/jsExtendedApi/jsApi.Array.mozExtensions.js

eine dem mir vorschwebenden ideal nahekommende
   loesung koennte also folgendermassen aussehen:

~~~javascript var arr = ["12,45", "9,525", "13,1", "7,15", "126,3", "37,8845", "21,965"];
   arr = arr.join("|").replace((/,/g), ".").split("|").map(function (elm, idx, arr) {return Number(parseFloat(elm));});
   alert((arr.toSource) ? (arr.toSource()) : (arr));

  
  

> Danke,  
> Paul  
  
   gern geschehen - peterS. - pseliger@gmx.net  
  

-- 
»Because objects in JavaScript are so flexible, you will want to think differently about class hierarchies.  
Deep hierarchies are inappropriate. Shallow hierarchies are efficient and expressive.« - [Douglas Crockford](http://javascript.crockford.com/)  
  
ie:( fl:) br:> va:( ls:& fo:) rl:| n3;} n4:} ss:} de:µ js:} mo:? zu:]