Métodos


Introducción

JavaScript incluye un pequeño conjunto de métodos estándar que están disponibles en los tipos estándar.

Array

array.concat(item...)

El método concat produce una nueva matriz que contiene una copia superficial de esta matriz con el elemento s abexado al final. Si un elemento es una matriz, entonces cada uno de sus elementos se adjunta por separado. También vea array.push(item...) más adelante en este capítulo.

var a = ['a', 'b', 'c'];
var b = ['x', 'y', 'z'];
var c = a.concat(b, true);
// c is ['a', 'b', 'c', 'x', 'y', 'z', true]

array.join(separator)

El método join hace una cadena a partir de una matriz. Esto lo logra haciendo una cadena de cada uno de los elementos del array, y luego concatena todos juntos con un separador entre ellos. El separador predeterminado es ',' . Para unir sin separación, utilice una cadena vacía como el separador .

Si estas ensamblando una cadena con un gran número de piezas, por lo general es más rápido poner las piezas en una matriz y utilizar join que concatenar los pedazos con el operador +:

var a = ['a', 'b', 'c'];
a.push('d');
var c = a.join(''); // c is 'abcd';

array.pop()

Los métodos pop y push hacen una labor de matriz como una pila.  El método pop elimina y devuelve el último elemento en esta matriz. Si la matriz está vacía, devuelve undefined.

var a = ['a', 'b', 'c'];
var c = a.pop( ); // a is ['a', 'b'] & c is 'c'

puedes implementar pop así;

Array.method('pop', function ( ) {
    return this.splice(this.length - 1, 1)[0];
});

array.push(item...)

El método push agrega elementos al final de una matriz. A diferencia del método concat, modifica la matriz y añade elementos de matriz. Devuelve la nueva longitud de la matriz:

var a = ['a', 'b', 'c'];
var b = ['x', 'y', 'z'];
var c = a.push(b, true);
// a is ['a', 'b', 'c', ['x', 'y', 'z'], true]
// c is 5;

push se puede implementar así:

Array.method('push', function ( ) {
    this.splice.apply(
        this,
        [this.length, 0].
            concat(Array.prototype.slice.apply(arguments)));
    return this.length;
});

array.reverse()

El método reverse modifica la matriz invirtiendo el orden de los elementos. Y retorna una matriz :

var a = ['a', 'b', 'c'];
var b = a.reverse( );
// both a and b are ['c', 'b', 'a']

array.shift()

El método shift elimina el primer elemento de una matriz y lo devuelve. Si la matriz está vacía, devuelve undefined . shift es normalmente mucho más lento que pop :

var a = ['a', 'b', 'c'];
var c = a.shift( );
// a is ['b', 'c'] & c is 'a'
shift can be implemented like this:
Array.method('shift', function ( ) {
    return this.splice(0, 1)[0];
});

array.slice(start, end)

El método slice hace una copia superficial de una porción de una matriz. El primer elemento copiado será la matriz[inicio]. Se detiene antes de copiar la matriz[fin] . El parámetro es opcional, y el valor predeterminado es array.length . Si cualquiera de los dos parámetros es negativo, array.length se añadirán a ellos en un intento de hacerlos no negativos. Si inicio es mayor que o igual a matriz. el resultado de length será una nueva matriz vacía. No debes confundirlo slice con splice. Ver también string.slice más adelante.

var a = ['a', 'b', 'c'];
var b = a.slice(0, 1);       // b is ['a']
var c = a.slice(1);          // c is ['b', 'c']
var d = a.slice(1, 2);       // d is ['b']

array.sort(comparefn)

El método sort ordena el contenido de una matriz en su lugar. Ordena matrices de números de forma incorrecta:

var n = [4, 8, 15, 16, 23, 42];
n.sort( );
// n is [15, 16, 23, 4, 42, 8]

La función de comparación predeterminada de JavaScript asume que los elementos a ordenar son cadenas. No es lo suficientemente inteligente como para probar el tipo de los elementos antes de comparar, por lo que convierte los números en cadenas cuando se les compara, lo que garantiza un resultado incorrecto e indignante.

Afortunadamente, se puede sustituir la función de comparación con una propia.
La función de comparación debe tener dos parámetros y devuelve 0 si los dos parámetros son iguales, un número negativo si el primer parámetro es el primero, y un número positivo si el segundo parámetro debería ser el primera. (Old-timers might be reminded of the FORTRAN II arithmetic IF statement.)

n.sort(function (a, b) {
return a - b;
});
// n is [4, 8, 15, 16, 23, 42];

Esa función ordena números, pero no ordena cadenas. Si queremos ser capaces de resolver cualquier matriz de valores simples, tenemos que trabajar más duro: 

var m = ['aa', 'bb', 'a', 4, 8, 15, 16, 23, 42];
m.sort(function (a, b) {
    if (a === b) {
        return 0;
    }
    
    if (typeof a === typeof b) {
        return a < b ? -1 : 1;
    }
    return typeof a < typeof b ? -1 : 1;
});
// m is [4, 8, 15, 16, 23, 42, 'a', 'aa', 'bb']

Si el caso no es significativo, su función de comparación debería convertir los operandos a minúsculas antes de compararlos. Puedes ver string.localeCompare más adelante en este capítulo. Con una función de comparación más inteligente, podemos ordenar un array de objetos. Para hacer las cosas más fáciles para el caso general, vamos a escribir una función que hará funciones de comparación:

    // Function by takes a member name string and returns
// a comparison function that can be used to sort an
// array of objects that contain that member.
var by = function (name) {
    return function (o, p) {
        var a, b;
        if (typeof o === 'object' && typeof p === 'object' && o && p) {
            
            a = o[name];
            b = p[name];
            
            if (a === b) {
                return 0;
            }
            
            if (typeof a === typeof b) {
                return a < b ? - 1 : 1;
            }
            
            return typeof a < typeof b ? - 1 : 1;
        } else {
            throw {
                name: 'Error',
                message: 'Expected an object when sorting by ' + name;
            };
        }
    };
};
        var s = [
            {first: 'Joe',    last: 'Besser'},
            {first: 'Moe',    last: 'Howard'},
            {first: 'Joe',    last: 'DeRita'},
            {first: 'Shemp',  last: 'Howard'},
            {first: 'Larry',  last: 'Fine'},
            {first: 'Curly',  last: 'Howard'}
        ];

        s.sort(by('first'));   // s is [
        //  {first: 'Curly', last: 'Howard'},
        //  {first: 'Joe',   last: 'DeRita'},
        //  {first: 'Joe',   last: 'Besser'},
        //  {first: 'Larry', last: 'Fine'},
        //  {first: 'Moe',   last: 'Howard'},
        //  {first: 'Shemp', last: 'Howard'}
        // ]

El método sort no es estable, por lo que:

s.sort(by('first')).sort(by('last'));

no está garantizado para producir la secuencia correcta. Si deseas ordenar por varias claves, y una vez más tenemos que hacer más trabajo. Se puede modificar para tomar un segundo parámetro, otro método compare que será llamado a romper con los vínculos cuando las claves principales producen una coincidencia:

//Function by takes a member name string and an
//optional minor comparison function and returns
//a comparison function that can be used to sort an
//array of objects that contain that member. The
//minor comparison function is used to break ties
// when the o[name] and p[name] are equal.
var by = function (name, minor) {
    return function (o, p) {
        var a, b;
        if (o && p && typeof o === 'object' && typeof p === 'object') {
            a = o[name];
            b = p[name];
            if (a === b) {
                return typeof minor === 'function' ? minor(o, p) : 0;
            }
            
            if (typeof a === typeof b) {
                return a < b ? - 1 : 1;
            }
            return typeof a < typeof b ? - 1 : 1;
        } else {
            throw {
                name: 'Error',
                message: 'Expected an object when sorting by ' + name;
            };
        }
    };
};
        s.sort(by('last', by('first'))); // s is [
//        {first: 'Joe',     last: 'Besser'},
//        {first: 'Joe',     last: 'DeRita'},
//        {first: 'Larry',  last: 'Fine'},
//        {first: 'Curly',  last: 'Howard'},
//        {first: 'Moe',   last: 'Howard'},
//        {first: 'Shemp', last: 'Howard'}
// ]

array.splice(start, deleteCount, item...)

El método splice elimina elementos de una matriz, reemplazándolos con nuevos elementos. El parámetro inicio es el número de una posición dentro de la matriz. El parámetro DeleteCount es el número de elementos a eliminar a partir de esa posición. Si hay parámetros adicionales, esos elementos se insertarán en la posición. Devuelve una matriz que contiene los elementos eliminados.

El uso más popular de splice es borrar elementos de una matriz. No se debe confundir splice con slice:
 

var a = ['a', 'b', 'c'];
var r = a.splice(1, 1, 'ache', 'bug');
// a is ['a', 'ache', 'bug', 'c']
// r is ['b']

Puedes implementar splice así:

Array.method('splice', function (start, deleteCount) {
    var max = Math.max,
            min = Math.min,
            delta,
            element,
            insertCount = max(arguments.length - 2, 0),
            k = 0,
            len = this.length,
            new_len,
            result = [],
            shift_count;
    start = start || 0;
    if (start < 0) {
        start += len;
    }
    start = max(min(start, len), 0);
    deleteCount = max(min(typeof deleteCount === 'number' ?
            deleteCount : len, len - start), 0);
    delta = insertCount - deleteCount;
    new_len = len + delta;
    while (k < deleteCount) {
        element = this[start + k];
        if (element !== undefined) {
            result[k] = element;
        }
        k += 1;
    }
    shift_count = len - start - deleteCount;
    if (delta < 0) {
        k = start + insertCount;
        while (shift_count) {
            this[k] = this[k - delta];
            k += 1;
            shift_count -= 1;
        }
        this.length = new_len;
    } else if (delta > 0) {
        k = 1;
        while (shift_count) {
            this[new_len - k] = this[len - k];
            k += 1;
            shift_count -= 1;
        }
    }
    for (k = 0; k < insertCount; k += 1) {
        this[start + k] = arguments[k + 2];
    }
    return result;
});

array.unshift(item...)

El método unshift es como el método push excepto que empuja los elementos a la parte delantera de esta matriz en lugar de hacerlo al final de la matriz. Retorna la nueva longitud de la matriz.

var a = ['a', 'b', 'c'];
var r = a.unshift('?', '@');
// a is ['?', '@', 'a', 'b', 'c']
// r is 5

Funciones

function.apply(thisArg, argArray)

El método apply invoca una función, pasando en el objeto que se va a vincular a this una matriz opcional de argumentos. El método apply es utilizado en el patron de invocación a aplicar.

(Herencia)

Function.method('bind', function (that) {
    // Return a function that will call this function as
    // though it is a method of that object.
    var method = this,
    slice = Array.prototype.slice,
    args = slice.apply(arguments, [1]);
    return function ( ) {
        return method.apply(that, args.concat(slice.apply(arguments, [0])));
    };
});

var x = function ( ) {
    return this.value;
}.bind({value: 666});

alert(x( )); // 666

Números

number.toExponential(fractionDigits)

El método toExponential convierte este número en una cadena en forma exponencial. El parámetro opcional fractionDigits controla el número de posiciones decimales. Debe estar entre 0 y 20:

    document.writeln(Math.PI.toExponential(0));
    document.writeln(Math.PI.toExponential(2));
    document.writeln(Math.PI.toExponential(7));
    document.writeln(Math.PI.toExponential(16));
    document.writeln(Math.PI.toExponential( ));

    // Produces
    3e+0
    3.14e+0
    3.1415927e+0
    3.1415926535897930e+0
    3.141592653589793e+0

number.toFixed(fractionDigits)

El método toFixed convierte este número en una cadena en forma decimal. El parámetro opcional fractionDigits controla el número de posiciones decimales. Debe estar entre 0 y 20 El valor por defecto es 0:

document.writeln(Math.PI.toFixed(0));
document.writeln(Math.PI.toFixed(2));
document.writeln(Math.PI.toFixed(7));
document.writeln(Math.PI.toFixed(16));
document.writeln(Math.PI.toFixed( ));

// Produces

3
3.14
3.1415927
3.1415926535897930
3

number.toPrecision(precision)

El método toPrecision convierte este number en una cadena en forma decimal. El parámetro opcional de precision controla el número de dígitos de precisión. Debe estar entre 1 y 21:
 

document.writeln(Math.PI.toPrecision(2));
document.writeln(Math.PI.toPrecision(7));
document.writeln(Math.PI.toPrecision(16));
document.writeln(Math.PI.toPrecision( ));
// Produces
3.1
3.141593
3.141592653589793
3.141592653589793

number.toString(radix)

El método toString convierte este number en una cadena. El parámetro opcional radix controla laraíz o base. Debe estar entre 2 y 36. El radix base predeterminado es 10. El parámetro radix se utiliza más comúnmente con números enteros, pero se puede utilizar en cualquier número.

document.writeln(Math.PI.toString(2));
document.writeln(Math.PI.toString(8));
document.writeln(Math.PI.toString(16));
document.writeln(Math.PI.toString( ));
// Produces
11.001001000011111101101010100010001000010110100011
3.1103755242102643
3.243f6a8885a3
3.141592653589793

Objetos

object.hasOwnProperty(name)

El método hasOwnProperty retorna true si el objeto contiene una propiedad que tiene nombre. La cadena de prototipo no es examinada. Este método es inútil si el nombre es hasOwnProperty:

var a = {member: true};              
var b = Object.create(a);            // from Chapter 3
var t = a.hasOwnProperty('member');  // t is true
var u = b.hasOwnProperty('member');  // u is false 
var v = b.member;                    // v is true

RegExp

regexp.exec(string)

El método exec es el más poderoso (y más lento) de los métodos que utilizan expresiones regulares. Si coincide con éxito regexp y el string, retorna una matriz. El elemento 0 de la matriz contendrá la subcadena que coincide con la regexp. El elemento 1 es el texto capturado por el grupo 1, el elemento 2 es el texto capturado por el grupo 2, y así sucesivamente. Si la comparación falla, se devuelve un valor nulo.

Si regexp tiene una bandera a g, las cosas son un poco más complicadas. La búsqueda no comienza en la posición 0 de la cadena, sino en la posición regexp.lastIndex (que inicialmente es de cero). Si lo encuentra con exito, entonces regexp.lastIndex se establece en la posición del primer carácter después encontrarlo. Una coincidencia no satisfactoria restablece regexp.lastIndex a 0.

Esto le permite buscar por varias ocurrencias de un patron en un string llamando exec en un loop. Hay un par de cosas a tener en cuenta. Si se sale del bucle anticipadamente, debes restablecer regexp.lastIndex a 0 tu mismo antes de entrar en el bucle nuevamente. Además, el factor ^ coincide sólo cuando regexp.lastIndex es 0:

regexp.test(string)

El método de prueba es la más simple (y más rápido) de los métodos que utilizan expresiones regulares. Si la expresión regular coincide con la cadena , devuelve true; de lo contrario, devuelve false. No utilice la bandera g con este método:

var b = /&.+;/.test('frank & beans');
// b is true

la prueba podría ser implementado como:

RegExp.method('test', function (string) {
    return this.exec(string) !== null;
});

String

string.charAt(pos)

El método charAt devuelve el carácter de la posición pos en esta cadena. Si pos es menor que cero o mayor o igual a string.length devuelve la cadena vacía. JavaScript no tiene un tipo de caracteres. El resultado de este método es una cadena:

var name = 'Curly';
var initial = name.charAt(0);
// initial is 'C'
charAt could be implemented as:
String.method('charAt', function (pos) {
    return this.slice(pos, pos + 1);
});

string.charCodeAt(pos)

El método charCodeAt es el mismo que charAt excepto que en lugar de devolver una cadena, devuelve una representación entero del valor de punto del código del carácter en la posición pos de esa cadena. Si pos es menor que cero o mayor o igual a string.length devuelve NaN :

var name = 'Curly';
var initial = name.charCodeAt(0); // initial is 67

string.concat(string...)

El método concat crea una nueva cadena concatenando otras cadenas. Se usa rara vez debido a que el operador + es más conveniente:

var s = 'C'.concat('a', 't');
// s is 'Cat'

string.indexOf(searchString, position)

El método indexOf busca por una cadena de busqueda dentro de una cadena. Si la encuentra, devuelve la posición del primer carácter coincidente; de lo contrario, devuelve -1. El parámetro position opcional hace que comience la búsqueda en alguna posición especificada de la cadena :

var text = 'Mississippi';
var p = text.indexOf('ss');  // p is 2
p = text.indexOf('ss', 3);   // p is 5
p = text.indexOf('ss', 6);   // p is -1

 string.lastIndexOf(searchString, position)

El método lastIndexOf es como el método indexOf, excepto que busca desde el final de la cadena en lugar de la parte  de adelante:

var text = 'Mississippi';
var p = text.lastIndexOf('ss'); // p is 5
p = text.lastIndexOf('ss', 3);  // p is 2
p = text.lastIndexOf('ss', 6);  // p is 5

string.localeCompare(that)

El método localCompare compara dos cadenas. Las reglas de cómo se comparan las cadenas no están especificadas. Si esta cadena es inferior a esa cadena, el resultado es negativo. Si son iguales, el resultado es cero. Esto es similar a la convención de la función de comparación array.sort:

var m = ['AAA', 'A', 'aa', 'a', 'Aa', 'aaa'];
m.sort(function (a, b) {
    return a.localeCompare(b);
});
//  m (in some locale) is
//  ['a', 'A', 'aa', 'Aa', 'aaa', 'AAA']

string.match(regexp)

El método match coincide con una cadena y una expresión regular. El cómo hace esto se debe a la bandera g. Si no hay una bandera g, entonces el resultado de la llamada string.match(regexp) es lo mismo que llamar a regexp.exec(string) . Sin embargo, si regexp tiene la bandera g, entonces se produce una matriz de todas las coincidencias, pero excluye los grupos de captura:

 

Añadir nuevo comentario

CAPTCHA
Esta pregunta es para comprobar si usted es un visitante humano y prevenir envíos de spam automatizado.
5 + 2 =
Resuelva este simple problema matemático y escriba la solución; por ejemplo: Para 1+3, escriba 4.