1. On considère que les neuf dixièmes du code correspondent à environ 90% du temps de développement. Les 10% restant correspondent également à 90% du temps de développement - Tom Cargill
2. Vous ne pouvez pas comprendre la récursivité sans avoir d’abord compris la récursivité – Auteur Inconnu
3. J’ai toujours rêvé que mon ordinateur soit aussi simple à utiliser que mon téléphone. Ce rêve est devenu réalité : je ne comprends plus comment utiliser mon téléphone - Bjarne Stroustrup
4. Un ordinateur vous permet de faire plus de bêtises, beaucoup plus rapidement, que n’importe quelle autre invention dans l’histoire de l’humanité. À l’exception notable des armes à feu et de la tequila - Mitch Ratcliffe
5. Il y existe deux manières de concevoir un logiciel. La première, c’est de le faire si simple qu’il est évident qu’il ne présente aucun problème. La seconde, c’est de le faire si compliqué qu’il ne présente aucun problème évident. La première méthode est de loin la plus complexe - C.A.R. Hoare
6. Le fossé séparant théorie et pratique est moins large en théorie qu’il ne l’est en pratique - Auteur Inconnu
7. Si les ouvriers construisaient les bâtiments comme les développeurs écrivent leurs programmes, le premier pivert venu aurait détruit toute civilisation - Gerald Weinberg
8. Si debugger, c’est supprimer des bugs, alors programmer ne peut être que les ajouter - Edsger Dijkstra
9. Mesurer la progression du développement d’un logiciel à l’aune de ses lignes de code revient à mesurer la progression de la construction d’un avion à l’aune de son poids - Bill Gates
10. Neuf femmes ne peuvent pas faire un bébé en un mois - Fred Brooks
11. Aujourd’hui, la programmation est devenue une course entre le développeur, qui s’efforce de produire de meilleures applications à l’épreuve des imbéciles et l’univers, qui s’efforce de produire de meilleurs imbéciles. Pour l’instant, l’univers a une bonne longueur d’avance - Rich Cook
12. Les deux principales inventions sorties de Berkeley sont UNIX et le LSD. Difficile de croire à une quelconque coïncidence - Jeremy S. Anderson
13. Avant de vouloir qu’un logiciel soit réutilisable, il faudrait d’abord qu’il ait été utilisable - Ralph Johnson

Un grand merci à Frédéric

Voici donc la source, vous pourrez constater qu'elle est très proche de celle de la version PHP. Je n'ai pas poussé le vice jusqu'à utiliser la fonction abs() de Kevin.

function intval( mixed_var, base ) {
    // http://kevin.vanzonneveld.net
    // +   original by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +   improved by: stensi
    // +   bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // *     example 1: intval('Kevin van Zonneveld');
    // *     returns 1: 0
    // *     example 2: intval(4.2);
    // *     returns 2: 4
    // *     example 3: intval(42, 8);
    // *     returns 3: 42
    // *     example 4: intval('09');
    // *     returns 4: 9
 
    var tmp;
 
    var type = typeof( mixed_var );
 
    if(type == 'boolean'){
        if (mixed_var == true) {
            return 1;
        } else {
            return 0;
        }
    } else if(type == 'string'){
        tmp = parseInt(mixed_var * 1);
        if(isNaN(tmp) || !isFinite(tmp)){
            return 0;
        } else{
            return tmp.toString(base || 10);
        }
    } else if(type == 'number' && isFinite(mixed_var) ){
        return Math.floor(mixed_var);
    } else{
        return 0;
    }
}
 
function floatval(mixed_var) {
    // +   original by: Michael White (http://getsprink.com)
    // %        note 1: The native parseFloat() method of JavaScript returns NaN when it encounters a string before an int or float value.
    // *     example 1: floatval('150.03_page-section');
    // *     returns 1: 150.03
    // *     example 2: floatval('page: 3');
    // *     returns 2: 0
    // *     example 2: floatval('-50 + 8');
    // *     returns 2: -50
 
    return (parseFloat(mixed_var) || 0);
}
 
/**
 * Arrondit à la précision supérieure
 * @param float value Valeur à arrondir
 * @param float precision Précision (défaut: 1)
 * @return float
 */
function ceilp(value, precision) {
	precision = Math.abs(intval(precision));
	value = floatval(value);
	if (precision==1)||(precision==0)) {
		value = ceil(value);
	} else {
		value ceil(value/precision)*precision;
	}
	return value;
}
 
/**
 * Arrondit à la précision inférieure
 * @param float value Valeur à arrondir
 * @param float precision Précision (défaut: 1)
 * @return float
 */
function floorp(value, precision) {
	precision = Math.abs(intval(precision));
	value = floatval(value);
	if ((precision==1)||(precision==0)) {
		value = floor(value);
	} else {
		value floor(value/precision)*precision;
	}
	return value;
}