here I leave these functions them of vb so that they use in js
this helped them to that the programmers of vb are used functions of vb in js

code:

---

// Constantes
var vbCr = "\r";
var vbLf = "\n";
var vbCrLf = vbCr+vbLf;
var vbTab = "\t";

function Left(s, n){
    // Devuelve los n primeros caracteres de la cadena
                //It gives back to the n first characters of the chain
    if(n>s.length)
        n=s.length;
       
    return s.substring(0, n);
}
function Right(s, n){
    // Devuelve los n últimos caracteres de la cadena
    // It gives back to the n last characters of the chain
    var t=s.length;
    if(n>t)
        n=t;
       
    return s.substring(t-n, t);
}
function Mid(s, n, c){
    // Devuelve una cadena desde la posición n, con c caracteres
    // Si c = 0 devolver toda la cadena desde la posición n

                // Gives back a chain from position n, with c
                // characters If c = 0 to give back all the chain from position n     
    var numargs=Mid.arguments.length;
   
    // Si sólo se pasan los dos primeros argumentos
    // If first arguments only go both
    if(numargs<3)
        c=s.length-n+1;
       
    if(c<1)
        c=s.length-n+1;
    if(n+c >s.length)
        c=s.length-n+1;
    if(n>s.length)
        return "";
       
    return s.substring(n-1,n+c-1);
}
function LTrim(s){
    // Devuelve una cadena sin los espacios del principio
    // It gives back a chain without the spaces of the principle
    var i=0;
    var j=0;
   
    // Busca el primer caracter <> de un espacio
    // <> of a space looks for the first character
    for(i=0; i<=s.length-1; i++)
        if(s.substring(i,i+1) != ' '){
            j=i;
            break;
        }
    return s.substring(j, s.length);
}
function RTrim(s){
    // Quita los espacios en blanco del final de la cadena
    //Acquittal the spaces in target of the end of the chain
    var j=0;
   
    // Busca el último caracter <> de un espacio
    // <> of a space looks for the last character
    for(var i=s.length-1; i>-1; i--)
        if(s.substring(i,i+1) != ' '){
            j=i;
            break;
        }
    return s.substring(0, j+1);
}
function Trim(s){
    // Quita los espacios del principio y del final
    // Acquittal the spaces of the principle and the end
    return LTrim(RTrim(s));
}
function InStr(n, s1, s2){
    // Devuelve la posición de la primera ocurrencia de s2 en s1
    // Si se especifica n, se empezará a comprobar desde esa posición
    // Sino se especifica, los dos parámetros serán las cadenas

    // It gives back the position of the first occurrence of s2 in s1
    // If n is specified, it will begin to verify from that position
    // But it is specified, both parameters will be the chains

    var numargs=InStr.arguments.length;
   
    if(numargs<3)
        return n.indexOf(s1)+1;
    else
        return s1.indexOf(s2, n)+1;
}
function RInStr(n, s1, s2){
    // Devuelve la posición de la última ocurrencia de s2 en s1
    // Si se especifica n, se empezará a comprobar desde esa posición
    // Sino se especifica, los dos parámetros serán las cadenas

    // It gives back the position of the last occurrence of s2 in s1
    // If n is specified, it will begin to verify from that position
    // But it is specified, both parameters will be the chains

    var numargs=RInStr.arguments.length;
   
    if(numargs<3)
        return n.lastIndexOf(s1)+1;
    else
        return s1.lastIndexOf(s2, n)+1;
}
function Space{
    // Devuelve una cadena con n espacios
    // It gives back to a chain with n spaces

    var t="";
   
    for(var i=1; i<=n; i++)
        t=t+" ";
   
    return t;
}
function jString(n, c){
    // Devuelve n veces el caracter c
    // Character c gives back to n times
    var t="";
   
    for(var i=1; i<=n; i++)
        t=t+c;
    return t;
}
function UCase(s){
    // Devuelve la cadena convertida a mayúsculas
    // It gives back the turned chain to capital letters
    return s.toUpperCase();
}
function LCase(s){
    // Devuelve la cadena convertida en minúsculas
    // It gives back the chain turned small letters
    return s.toLowerCase();
}
function Len(s){
    // Devuelve la longitud de la cadena s
    // It gives back the length of chain s
    return s.length;
}
function StrReverse(s){
    // Invierte la cadena
    // It invests the chain
    var i=s.length;
    var t="";
   
    while(i>-1){
        t=t+ s.substring(i,i+1);
        i--;
    }
    return t;
}

---

Great class, I think this can really help people!

quote:

---

Originally posted by cicklow
here I leave these functions them of vb so that they use in js
this helped them to that the programmers of vb are used functions of vb in js

---

Nice

quote:

---

Originally posted by .Lou

quote:

---

Originally posted by cicklow
here I leave these functions them of vb so that they use in js
this helped them to that the programmers of vb are used functions of vb in js

---

I can see from the code what this does, but your explanation didn't really help

---

quote:

---

Originally posted by Ezra

quote:

---

Originally posted by .Lou
I can see from the code what this does, but your explanation didn't really help

---

It's a class to use VB functions that are not in available in Jscript.

---

The idea of cicklow is very nice , however....

Some functions listed do not work properly as their equivalent VB functions at all. And most of the functions are written in a way too complicated manner .

code:

---

////////////////////////////////////////////////////////////////////////////////////////////////////////
// Some VB Constants
////////////////////////////////////////////////////////////////////////////////////////////////////////

var vbCr = "\r";                          // ASCII code 13
var vbLf = "\n";                          // ASCII code 10
var vbFormFeed = "\f";              // ASCII code 12
var vbCrLf = vbCr + vbLf;          // ASCII code 13 + 10
var vbNewLine = vbCr + vbLf;   // ASCII code 13 + 10 (can be only ASCII code 10 on some platforms)

var vbTab = "\t";                        // ASCII code 9
var vbVerticalTab = "\13";          // ASCII code 11

var vbNullChar = "\0";                // ASCII code 0
var vbNullString = new String();

var vbFalse = false;
var vbTrue = true;


////////////////////////////////////////////////////////////////////////////////////////////////////////
// Some VB Functions
////////////////////////////////////////////////////////////////////////////////////////////////////////

// Returns a string containing a specified number of characters from the left side of a string.
function Left(s, length) { return s.substring(0, length) }

// Returns a string containing a specified number of characters from the right side of a string (method 1).
function Right(s, length) { return s.substr(s.length-length) }

// Returns a string containing a specified number of characters from the right side of a string (method 2).
function Right(s, length) { return s.slice(-length) }

// Returns a string containing a specified number of characters from a string (length parameter is optional).
function Mid(s, start, length) { return s.substr(--start, length) }

// Returns a string containing a copy of a specified string without leading spaces
function LTrim(s) { return s.replace(/^\s+/g,"") }

// Returns a string containing a copy of a specified string without trailing spaces
function RTrim(s) { return s.replace(/\s+$/g,"") }

// Returns a string containing a copy of a specified string without leading and trailing spaces
function Trim(s) { return s.replace(/^\s+|\s+$/g,"") }

// Returns a string containing the specified string, converted to uppercase.
function UCase(s) { return s.toUpperCase() }

// Returns a string containing the specified string, converted to lowercase.
function LCase(s) { return s.toLowerCase() }

// Returns a string containing the specified string, converted to propercase.
function PCase(s) { return s.toLowerCase().replace(/\b(\w)/g, function($1) { return $1.toUpperCase() }) }

// Returns a number containing the number of characters in a string
function Len(s) { return s.length }

// Returns the position of the first occurrence of one string within another (start parameter is optional).
function InStr(start, s1, s2) {
        if (arguments.length === 3)
                return s1.indexOf(s2, --start)+1;
        else
                return start.indexOf(s1)+1;
}

// Returns the position of an occurrence of one string within another, from the end of string (start parameter is optional).
function InStrRev(s1, s2, start) {
        if (start < 0) start = s1.length;
        return s1.lastIndexOf(s2, --start)+1;
}

// Returns a string consisting of the specified number of spaces.
function Space(number) {
        var s = "";
        for (var i=0; i<number; i++) s += " ";
        return s;
}

// Returns a string containing a repeating character string of the length specified.
function StringVB(number, character) {
        if (typeof(character) === "number") character = String.fromCharCode(character);
        var s = "";
        for (var i=0; i<number; i++) s += character.charAt(0);
        return s;
}

// Returns a string in which the character order of a specified string is reversed (best to understand method).
function StrReverse1(s) {
        var t = "";
        for (var i=s.length; i>0;) t += s.charAt(--i);
        return t;
}

// Returns a string in which the character order of a specified string is reversed (faster and shorter method).
function StrReverse2(s) { return s.split("").reverse().join("") }

// Returns a number representing the character code corresponding to the first letter in a string.
function Asc(s) { return s.charCodeAt(0) }

// Returns a string containing the character associated with the specified character code.
function Chr(charcode) { return String.fromCharCode(charcode) }

// Returns the absolute value of a number.
function Abs(number) { return Math.abs(number) }

// Returns a string representing the hexadecimal value of a number.
function Hex(number) { return number.toString(16).toUpperCase() }

// Returns a string representing the octal value of a number.
function Oct(number) { return number.toString(8) }

// Returns a string representing the binary value of a number.
function Bin(number) { return number.toString(2) }

// Returns a string representing the decimal value of a number.
function Dec(number) { return number.toString(10) }

// Returns a decimal number from a string representing the hexadecimal value of a number.
function Hex2Dec(s) { return parseInt(s, 16) }

// Returns a decimal number from a string representing the octal value of a number.
function Oct2Dec(s) { return parseInt(s, 8) }

// Returns a decimal number from a string representing the binary value of a number.
function Bin2Dec(s) { return parseInt(s, 2) }

// Returns a number indicating the sign of a number.
function Sgn(number) { return number == 0 ? 0 : number < 0 ? -1 : 1 }

// Returns the integer portion of a number.
// The difference between Int and Fix is that if number is negative, Int Returns the first negative integer less than or equal to number. For example, Int converts -8.4 to -9.
function Int(number) { return Math.floor(number) }

// Returns the integer portion of a number.
// The difference between Int and Fix is that if number is negative, Fix Returns the first negative integer greater than or equal to number. For example, Fix converts -8.4 to -8.
function Fix(number) { return parseInt(number) }

// Returns a random number.
function Rnd() { return Math.random() }

// Returns a random integer number in a range
//   lowerbound    (required) Specifies the lower limit of the range (limit inclusief)
//   upperbound    (required) Specifies the upper limit of the range (limit inclusief)
function RndBetween(lowerbound, upperbound) {
        lowerbound = Math.min(lowerbound, upperbound);
        upperbound = Math.max(lowerbound, upperbound);
        return Math.floor((upperbound - lowerbound + 1) * Math.random() + lowerbound);
}

// Returns the factorial of a number.
function Factorial(number) {
        if (number < 0) return undefined;
        return number < 2 ? 1 : Math.floor(number) * arguments.callee(--number);
}



// Additional function which behaves like VB6 Replace function.
// Note that I didn't directly use a regular expression replacement because of the pitfalls when strings contain special regular expression characters. This can be worked around, but to keep this example simple I didn't choose to do so.

// Returns a string in which a specified substring has been replaced with another substring a number of times.
//    s                 (required) String containing substring to replace.
//    findtext       (required) Substring being searched for.
//    replacetext  (required) Replacement substring.
//    start           (optional) Position within s where substring search is to begin. If omitted, 1 is assumed.
//    count          (optional) Number of substring substitutions to perform. If omitted, make all possible substitutions.
function Replace(s, findtext, replacetext, start, count) {
        if (count === -1 || count == undefined) count = s.length;
        if (start < 1 || start == undefined) start = 1;
        var t = start--;
        while (count > 0 && start != t) {
                count--;
                t = start;
                s = s.substring(0, start) + s.substr(start).replace(
                        findtext, function($0, $1, $2) { start += $1 + replacetext.length; return replacetext }
                );
        }
        return s;
}

---

EDIT:

quote:

---

Originally posted by Plik

quote:

---

Originally posted by CookieRevised
// Returns a string representing the octal value of a number.
function Oct(number) { return number.toString(8).toUpperCase() }

---

You don't even need to use toUpperCase there because octal is 0 to 7

---

yeah, was a stupid copy/paste left-over... was edited before I saw your post though.

quote:

---

Originally posted by Plik
But otherwise good work

---

Thanks, but main idea comes from cicklow.

Update: new functions added (PCase, StrReverse, Rnd, RndBetween, Factorial)

EDIT: some functions (mostly those with the Replace() function) can be optimized or made even shorter though... will do when I have some time


Previous downloads: 15

quote:

---

Originally posted by CookieRevised
// Returns a string representing the octal value of a number.
function Oct(number) { return number.toString(8).toUpperCase() }

---

quote:

---

Originally posted by CookieRevised
I think Lou means the English explanations are dodgy (machine translated).

---

quote:

---

Originally posted by CookieRevised
function String(number, character) {
        if (typeof(character) === "number") character = String.fromCharCode(character);
        var s = "";
        for (var i=0; i<number; i++) s += character.charAt(0);
        return s;
}

---