Tester type de variable

Version imprimable

Bonjour,

J'ai crée une fonction ayant l'objectif de tester le type d'une variable.

Cependant le résultat n'est pas celui que je pensais obtenir. La fonction me retourne toujours que la variable est de type String. Cependant ce n'ai pas toujours le cas.

Voici ma fonction:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 function processRow(rowData) { console.log("######"); var rowStructure = []; var rowIndex = 0; for(d in rowData) { var v = rowData[rowIndex].trim(); if(typeof v=="string") console.log(v + " is a String"); else if(typeof v=="number") console.log(v + " is a number"); else console.log(v + " is ?"); //console.log(rowData[rowIndex]); rowIndex++; } return rowStructure; }
Voici mon output:

Citation:

######
Title is a String
Description is a String
Year is a String
######
Braveheart is a String
A great movie is a String
1995 is a String -------------> ça devrait être détecté comme étant un numeric
######
Django is a String
Best 2013 movie is a String
2013 is a String -------------> ça devrait être détecté comme étant un numeric

Je pense que c'est un problème simple mais voici des années que je programme pas en Web et plus précisément en JS.

Merci

Déjà, je ne vois pas trop comment tu espères que ta fonction marche avec autre chose que des chaines étant donné que dans

Code:

var v = rowData[rowIndex].trim();

trim() est soit non implémenté, soit applicable uniquement à des chaines. Donc tu risque difficilement d'aller plus loin...

Ensuite, tu l'appelle avec quoi ta fonction ? Parce que
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 function processRow(rowData) { console.log("######"); var rowStructure = []; var rowIndex = 0; for(d in rowData) { var v = rowData[rowIndex]; if(typeof v=="string") console.log(v + " is a String"); else if(typeof v=="number") console.log(v + " is a number"); else console.log(v + " is ?"); //console.log(rowData[rowIndex]); rowIndex++; } return rowStructure; } processRow(['foo', 42])
Renvoie bien
######
foo is a String
42 is a number
[]

Bonjour,

Merci pour la réponse.

Le paramètre que ma fonction reçoit est un array de String.

Dans mon cas concret, la fonction est appellée 3 fois avec les paramètres suivants:
["Title", "Description", "Year"]
["Braveheart", " A great movie", " 1995"]
["Django", " Best 2013 movie", " 2013"]

Avec la fonction, mon objectif serait de détecter que l'élément "Braveheart" est bien une string mais que par contre l'élément " 1995" est un numérique.
En java j'avais déjà fais cela avec une fonction comme celle ci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 public static boolean isNumeric(final String str) { try { Double.parseDouble(str); return true; } catch(NumberFormatException nfe) { try { Integer.parseInt(str.substring(0, str.length()-1)); return true; } catch(NumberFormatException nfee) { try { Float.parseFloat(str.substring(0, str.length()-1)); return true; } catch(NumberFormatException nfeee) { return false; } } } }
Citation:
Code:

processRow(['foo', 42])

Renvoie bien
######
foo is a String
42 is a number
[]
OK MAIS:

Code:

processRow(["foo", "42"])

renvoi foo is a String
42 is a String

17/07/2014, 15h03
SylvainPV
Le test de type n'est pas un des plus grands succès de JavaScript :) typeof et instanceof ont tous les deux leurs défauts.

Voilà une fonction similaire à ce que fait jQuery.type :
Code:

1 2 3 function type(val){ return Object.prototype.toString.call(val).replace(/^\[object (.+)\]$/,"$1").toLowerCase(); }

Citation:

Le paramètre que ma fonction reçoit est un array de String.

Ben faut pas s'étonner qu'il t'indique que ce sont des chaines si tu lui passes des chaines ! :aie:

Tu peux en revanche créer une fonction qui vérifie si une chaine est au format numérique :
Code:

1 2 3 4 5 6 7 8 9 function is_numeric(st){ return +st == st; } console.log(is_numeric('foo42')); console.log(is_numeric('42bar')); console.log(is_numeric('25')); console.log(is_numeric(' 42 ')); console.log(is_numeric(42)); console.log(is_numeric(25.8));

pour info, mon implémentation de is_numericet is_integer :

is_numeric :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
function isNumber(n) {
  n = n.toString().replace(/,/g, '.'); // en chaine, puis convertir , en .  
  return !isNaN(parseFloat(n)) && isFinite(n);
}
 
console.log(isNumber(5)); // true
console.log(isNumber(4597)); // true
console.log(isNumber("lol")); // false
console.log(isNumber("9.489.")); // false
console.log(isNumber("9.489")); // true
console.log(isNumber("4579,312")); // true
console.log(isNumber("4,579,312")); // false
console.log(isNumber("5,2")); // true
console.log(isNumber("8e3")); // true
console.log(isNumber(",5")); // true
console.log(isNumber(".5")); // true

isInteger :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*\
|*|
|*|  :: Number.my_isSafeInteger() polyfill ::
|*|
|*|  <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/my_isSafeInteger" target="_blank">https://developer.mozilla.org/en-US/..._isSafeInteger</a>
|*|
\*/
 
// Note, the MDN polyfill is actually isSafeInteger polyfill
function my_isSafeInteger(n) {
  return typeof n === "number" && isFinite(n) && n >= (Number.MIN_SAFE_INTEGER || -9007199254740991) && n <= (Number.MAX_SAFE_INTEGER || 9007199254740992) && Math.floor(n) === n;
}
// [ES6 proposal](<a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.issafeinteger" target="_blank">https://people.mozilla.org/~jorendor....issafeinteger</a>) 
// already in Chrome 34+ : [Number.isSafeInteger](<a href="https://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/v8natives.js?r=18480#1655" target="_blank">https://code.google.com/p/v8/source/...s?r=18480#1655</a>)
 
/* These tests must be valid */
// Integers
console.assert(my_isSafeInteger(4597));
console.assert(my_isSafeInteger(8e3));
console.assert(my_isSafeInteger(-0));
console.assert(my_isSafeInteger(+0));
 
// !my_isSafeInteger
console.assert(!my_isSafeInteger("4598"));
console.assert(!my_isSafeInteger(Number.MAX_VALUE));
console.assert(!my_isSafeInteger(Infinity));
console.assert(!my_isSafeInteger(NaN));
console.assert(!my_isSafeInteger({}));
console.assert(!my_isSafeInteger(false));
console.assert(!my_isSafeInteger(true));
console.assert(!my_isSafeInteger(null));
console.assert(!my_isSafeInteger(undefined));
console.assert(!my_isSafeInteger("lol"));
console.assert(!my_isSafeInteger("9.489"));
console.assert(!my_isSafeInteger("4,579,312"));
console.assert(!my_isSafeInteger("5,2"));
console.assert(!my_isSafeInteger("8e3"));
console.assert(!my_isSafeInteger(".5"));
 
// my isInteger implementation
function my_isInteger(n) {
  return typeof n === "number" && isFinite(n) && Math.floor(n) === n;
}
// [ES6 proposal](<a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-number.isinteger" target="_blank">https://people.mozilla.org/~jorendor...mber.isinteger</a>) 
// already in Chrome 34+ : [Number.isInteger](<a href="https://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/v8natives.js?r=18480#1642" target="_blank">https://code.google.com/p/v8/source/...s?r=18480#1642</a>)
 
/* These tests must be valid */
// Integers
console.assert(my_isInteger(4597));
console.assert(my_isInteger(8e3));
console.assert(my_isInteger(Number.MAX_VALUE));
console.assert(my_isInteger(-0));
console.assert(my_isInteger(+0));
 
// !my_isInteger
console.assert(!my_isInteger("4598"));
console.assert(!my_isInteger(Infinity));
console.assert(!my_isInteger(NaN));
console.assert(!my_isInteger({}));
console.assert(!my_isInteger(false));
console.assert(!my_isInteger(true));
console.assert(!my_isInteger(null));
console.assert(!my_isInteger(undefined));
console.assert(!my_isInteger("lol"));
console.assert(!my_isInteger("9.489"));
console.assert(!my_isInteger("4,579,312"));
console.assert(!my_isInteger("5,2"));
console.assert(!my_isInteger("8e3"));
console.assert(!my_isInteger(".5"));