Many improvements

kvz · kvz · commit 35e048d617bf · 2009-01-25T12:33:43.000Z
diff --git a/_tools/t.php b/_tools/t.php
@@ -6,7 +6,10 @@
 //echo mktime(0, 0, 0, 1, 1, 1998)."\n";
 
 
-echo mktime(0, 0, 0, 0, 1, 2008)."\n";
+echo strnatcasecmp("10", "1")."\n";
+echo strnatcasecmp(10, 1)."\n";
+echo strnatcasecmp('1', '10')."\n";
 //$x = get_html_translation_table(HTML_ENTITIES);
 //print_r($x);
-?>
+?>
+echo strnatcasecmp(10, 1)."\n";
diff --git a/_unported/array/natcasesort.js b/_unported/array/natcasesort.js
diff --git a/_unported/array/natsort.js b/_unported/array/natsort.js
diff --git a/_unported/strings/strnatcasecmp.js b/_unported/strings/strnatcasecmp.js
diff --git a/functions/array/arsort.js b/functions/array/arsort.js
@@ -16,8 +16,15 @@ function arsort(inputArr, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+            sorter = function (a, b) {
+                return strnatcmp(b, a);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(b.localeCompare(a));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(a - b);
diff --git a/functions/array/asort.js b/functions/array/asort.js
@@ -7,6 +7,7 @@ function asort(inputArr, sort_flags) {
     // %        note 1: http://sourcefrog.net/projects/natsort/natcompare.js
     // %        note 2: The examples are correct, this is a new way
     // %        note 2: Credits to: http://javascript.internet.com/math-related/bubble-sort.html
+    // -    depends on: strnatcmp
     // *     example 1: data = {d: 'lemon', a: 'orange', b: 'banana', c: 'apple'};
     // *     example 1: asort(data);
     // *     results 1: data == {c: 'apple', b: 'banana', d: 'lemon', a: 'orange'}
@@ -16,8 +17,15 @@ function asort(inputArr, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+            sorter = function (a, b) {
+                return strnatcmp(a, b);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(a.localeCompare(b));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(a - b);
diff --git a/functions/array/krsort.js b/functions/array/krsort.js
@@ -13,8 +13,15 @@ function krsort(array, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+            sorter = function (a, b) {
+                return strnatcmp(b, a);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with  i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(b.localeCompare(a));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(b - a);
diff --git a/functions/array/ksort.js b/functions/array/ksort.js
@@ -13,8 +13,15 @@ function ksort(array, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+            sorter = function (a, b) {
+                return strnatcmp(a, b);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with  i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(a.localeCompare(b));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(a - b);
diff --git a/functions/array/natcasesort.js b/functions/array/natcasesort.js
@@ -0,0 +1,47 @@
+function natcasesort(inputArr) {
+    // http://kevin.vanzonneveld.net
+    // +   original by: Brett Zamir
+    // -    depends on: strnatcasecmp
+    // *     example 1: $array1 = {0:'IMG0.png', 1:'img12.png', 2:'img10.png', 3:'img2.png', 4:'img1.png', 5:'IMG3.png'};
+    // *     example 1: natcasesort($array1);
+    // *     returns 1: {0: 'IMG0.png', 4: 'img1.png', 3: 'img2.png', 5: 'IMG3.png', 2: 'img10.png', 1: 'img12.png'}
+
+    var valArr=[], keyArr=[], k, i, ret;
+
+    var bubbleSort = function(keyArr, inputArr) {
+        var i, j, tempValue, tempKeyVal;
+        for (i = inputArr.length-2; i >= 0; i--) {
+            for (j = 0; j <= i; j++) {
+                ret = strnatcasecmp(inputArr[j+1], inputArr[j]);
+                if (ret < 0) {
+                    tempValue = inputArr[j];
+                    inputArr[j] = inputArr[j+1];
+                    inputArr[j+1] = tempValue;
+                    tempKeyVal = keyArr[j];
+                    keyArr[j] = keyArr[j+1];
+                    keyArr[j+1] = tempKeyVal;
+                }
+            }
+        }
+    };
+
+    // Get key and value arrays
+    for (k in inputArr) {
+        valArr.push(inputArr[k]);
+        keyArr.push(k);
+        delete inputArr[k] ;
+    }
+    try {
+        // Sort our new temporary arrays
+        bubbleSort(keyArr, valArr);
+    } catch(e) {
+        return false;
+    }
+
+    // Repopulate the old array
+    for (i = 0; i < valArr.length; i++) {
+        inputArr[keyArr[i]] = valArr[i];
+    }
+
+    return true;
+}
diff --git a/functions/array/natsort.js b/functions/array/natsort.js
@@ -0,0 +1,47 @@
+function natsort(inputArr) {
+    // http://kevin.vanzonneveld.net
+    // +   original by: Brett Zamir
+    // -    depends on: strnatcmp
+    // *     example 1: $array1 = {a:"img12.png", b:"img10.png", c:"img2.png", d:"img1.png"};
+    // *     example 1: natcasesort($array1);
+    // *     returns 1: {d: 'img1.png', c: 'img2.png', b: 'img10.png', a: 'img12.png'}
+
+    var valArr=[], keyArr=[], k, i, ret;
+
+    var bubbleSort = function(keyArr, inputArr) {
+        var i, j, tempValue, tempKeyVal;
+        for (i = inputArr.length-2; i >= 0; i--) {
+            for (j = 0; j <= i; j++) {
+                ret = strnatcmp(inputArr[j+1], inputArr[j]);
+                if (ret < 0) {
+                    tempValue = inputArr[j];
+                    inputArr[j] = inputArr[j+1];
+                    inputArr[j+1] = tempValue;
+                    tempKeyVal = keyArr[j];
+                    keyArr[j] = keyArr[j+1];
+                    keyArr[j+1] = tempKeyVal;
+                }
+            }
+        }
+    };
+
+    // Get key and value arrays
+    for (k in inputArr) {
+        valArr.push(inputArr[k]);
+        keyArr.push(k);
+        delete inputArr[k] ;
+    }
+    try {
+        // Sort our new temporary arrays
+        bubbleSort(keyArr, valArr);
+    } catch(e) {
+        return false;
+    }
+
+    // Repopulate the old array
+    for (i = 0; i < valArr.length; i++) {
+        inputArr[keyArr[i]] = valArr[i];
+    }
+
+    return true;
+}
diff --git a/functions/array/rsort.js b/functions/array/rsort.js
@@ -22,8 +22,15 @@ function rsort (inputArr, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+             sorter = function (a, b) {
+                return strnatcmp(b, a);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with  i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(b.localeCompare(a));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(b - a);
diff --git a/functions/array/sort.js b/functions/array/sort.js
@@ -23,8 +23,15 @@ function sort (inputArr, sort_flags) {
 
     switch (sort_flags) {
         case 'SORT_STRING': // compare items as strings
+            sorter = function (a, b) {
+                return strnatcmp(a, b);
+            };
+            break;
         case 'SORT_LOCALE_STRING': // compare items as strings, based on the current locale (set with  i18n_loc_set_default() as of PHP6)
-            throw 'Not implemented yet';
+            sorter = function (a, b) {
+                return(a.localeCompare(b));
+            };
+            break;
         case 'SORT_NUMERIC': // compare items numerically
             sorter = function (a, b) {
                 return(a - b);
diff --git a/functions/strings/strnatcasecmp.js b/functions/strings/strnatcasecmp.js
@@ -0,0 +1,117 @@
+function strnatcasecmp(str1, str2) {
+    // http://kevin.vanzonneveld.net
+    // +      original by: Martin Pool
+    // + reimplemented by: Pierre-Luc Paour
+    // + reimplemented by: Kristof Coomans (SCK-CEN (Belgian Nucleair Research Centre))
+    // + reimplemented by: Brett Zamir
+    // +      bugfixed by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
+    // *     example 1: strnatcasecmp(10, 1);
+    // *     returns 1: 1
+    // *     example 1: strnatcasecmp('1', '10');
+    // *     returns 1: -1
+
+    a = (str1+'').toLowerCase();
+    b = (str2+'').toLowerCase();
+
+    var isWhitespaceChar = function(a) {
+        return a.charCodeAt(0) <= 32;
+    }
+
+    var isDigitChar = function (a) {
+        var charCode = a.charCodeAt(0);
+        return ( charCode >= 48  && charCode <= 57 );
+    }
+
+    var compareRight = function(a,b) {
+        var bias = 0;
+        var ia = 0;
+        var ib = 0;
+
+        var ca;
+        var cb;
+
+        // The longest run of digits wins.  That aside, the greatest
+        // value wins, but we can't know that it will until we've scanned
+        // both numbers to know that they have the same magnitude, so we
+        // remember it in BIAS.
+        for (;; ia++, ib++) {
+            ca = a.charAt(ia);
+            cb = b.charAt(ib);
+
+            if (!isDigitChar(ca)
+                && !isDigitChar(cb)) {
+                return bias;
+            } else if (!isDigitChar(ca)) {
+                return -1;
+            } else if (!isDigitChar(cb)) {
+                return +1;
+            } else if (ca < cb) {
+                if (bias == 0) {
+                    bias = -1;
+                }
+            } else if (ca > cb) {
+                if (bias == 0)
+                    bias = +1;
+            } else if (ca == 0 && cb == 0) {
+                return bias;
+            }
+        }
+    }
+
+    var ia = 0, ib = 0;
+    var nza = 0, nzb = 0;
+    var ca, cb;
+    var result;
+
+    while (true) {
+        // only count the number of zeroes leading the last number compared
+        nza = nzb = 0;
+
+        ca = a.charAt(ia);
+        cb = b.charAt(ib);
+
+        // skip over leading spaces or zeros
+        while ( isWhitespaceChar( ca ) || ca =='0' ) {
+            if (ca == '0') {
+                nza++;
+            } else {
+                // only count consecutive zeroes
+                nza = 0;
+            }
+
+            ca = a.charAt(++ia);
+        }
+
+        while ( isWhitespaceChar( cb ) || cb == '0') {
+            if (cb == '0') {
+                nzb++;
+            } else {
+                // only count consecutive zeroes
+                nzb = 0;
+            }
+
+            cb = b.charAt(++ib);
+        }
+
+        // process run of digits
+        if (isDigitChar(ca) && isDigitChar(cb)) {
+            if ((result = compareRight(a.substring(ia), b.substring(ib))) != 0) {
+                return result;
+            }
+        }
+
+        if (ca == 0 && cb == 0) {
+            // The strings compare the same.  Perhaps the caller
+            // will want to call strcmp to break the tie.
+            return nza - nzb;
+        }
+
+        if (ca < cb) {
+            return -1;
+        } else if (ca > cb) {
+            return +1;
+        }
+
+        ++ia; ++ib;
+    }
+}
