Discussion :

[pjmorce]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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:

######
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

[Bovino]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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
[]

[pjmorce]

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 java :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
			  }
		  }
 
	  }  
	}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

processRow(['foo', 42])

Renvoie bien

######
foo is a String
42 is a number
[]

OK MAIS:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

renvoi foo is a String
42 is a String

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Bovino]

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 !

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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));

[Kaamo]

pour info, mon implémentation de is_numericet is_integer :

is_numeric :

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

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 javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

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"));