JavaScript Array/Struct

Question

Me gustaría crear una estructura dentro de javascript. Tengo un par de informaciones, me gustaría utilizar, ejemplo:

array[1] = new Struct(); 
array[1].name = "parameter-name"; 
array[1].value = "parameter-value"; 

array[2] = new Struct(); 
array[2].name = "parameter-name2"; 
array[2].value = "parameter-value2"; 

Esto puede estar en una página diversa con los valores de diffrent, tal vez en el elemento dentro de mi matriz, tal vez 2-20 ..

Más tarde, dentro de mi javascript genérico, me gustaría analizar la matriz y continuar con mi parámetros, ejemplo:

for(i=1 to length_of_my_array) { 
    _tag.array[i].name = array[i].value; 
} 

¿Cómo puedo realizar esto con javascript puro? Gracias por cualquier pista!

Answer 1

Mientras no desee ninguna característica sofisticada, es realmente fácil crear tales estructuras en JavaScript. De hecho, el código que envió casi funcionar, si se reemplaza la new Struct() con esto:

array[1] = {}; 

Esto crea un objeto vacío, y se puede poner cualquier propiedades que desee en ella, como name y value.

Para crear una matriz, se puede hacer algo como esto:

var array = []; // empty array 

// object literal notation to create your structures 
array.push({ name: 'abc', value: 'def' }); 
array.push({ name: 'ghi', value: 'jkl' }); 
... 

Y para iterar sobre la matriz:

for (var i = 0; i < array.length; i++) { 
    // use array[i] here 
} 

Answer 2

var array = {paramName: 'paramValue', paramName2: 'paramValue2'}; 

for(i in array) { 
    _tag.i = array.i; 
} 

Answer 3

No hay "estructura" en JavaScript único objeto

my_array = new Array(); 
my_array.push({name: 'john', age:31}); 
my_array.push({name: 'da_didi', age:120}); 

for (i=0; i<my_array.length; i++) 
{ 
    alert(my_array[i].name); 
} 

Answer 4

I would store objec t literales de la matriz, así:

var myArray = []; 

myArray[0] = {name:"some name", value:"some value"}; 
myArray[1] = {name:"another name", value:"another value"}; 

for (i=0; i < myArray.length; i++) { 
    console.log(myArray[i].name + '/' + myArray[i].value); 
} 

Answer 5

Se pueden definir matrices y objetos genéricos en JavaScript puro/JSON:

var array = []; // empty array 
array.push({name: 'parameter-name', value: 'parameter-value'}); 
array.push({name: 'parameter-name2', value: 'parameter-value2'}); 
console.log(array); 
// Output: 
// [Object { name="parameter-name", value="parameter-value2"}, Object { name="parameter-name2", value="parameter-value2"}] 

También puede definir la misma matriz de este modo:

var array = [ 
    {name: 'parameter-name', value: 'parameter-value'}, 
    {name: 'parameter-name2', value: 'parameter-value2'} 
]; 

por lo que bucle a través de la matriz:

for (var i = 0; i<array.length; i++) { 
    var elem = array[i]; 
    console.log(elem.name, elem.value); 
} 

// Outputs: 
// parameter-name parameter-value2 
// parameter-name2 parameter-value2 

Answer 6

// initialize empty array  
var myArray = []; 

// fill it with an object - the equivalent of a struct in javascript 
myArray.push({ 
    name: 'example-name' 
    value: 'example-value' 
}); 
// repeat as neccessary 

// walking through the array 
for (var i = 0; i < myArray.length; i++) 
{ 
    // retrieving the record 
    record = myArray[i]; 

    // and accessing a field 
    doSomething(record.name); 
} 

Answer 7

¿Qué hay de

function Struct(name, value) { 
    this.name = name; 
    this.value = value; 
} 

arr[0] = new Struct("name1", "value1"); 

Answer 8

objetos JavaScript son objetos sueltos: propiedades se pueden agregar y quitar de forma dinámica. Así que crear un nuevo Struct(), como sugiere, no garantiza que el objeto devuelto siempre tendrá las propiedades que espera que tenga. Usted tiene que comprobar la disponibilidad de propiedades en el punto de uso (duck typing):

var i, element; 
for (i = 0; i < array.length; i++) { 
    element = array[i]; 
    if (Object.hasOwnProperty.call(element, "name") 
     && Object.hasOwnProperty.call(element, "value")) { 
    _tag[element.name] = element.value; 
    } 
} 

(Además, soy sólo una suposición de que funciones acabadas en _tag es un objeto en sí mismo, pero que no era clara de su ejemplo.)

Probablemente podría utilizar una sintaxis más sucinta, pero eso depende en gran medida de los valores de las propiedades.Por ejemplo, -might- será capaz de utilizar algo como esto:

var i, element; 
for (i = 0; i < array.length; i++) { 
    element = array[i]; 
    if (element.name && element.value) { 
    _tag[element.name] = element.value; 
    } 
} 

Pero hay que darse cuenta de que la condición anterior será falsa no sólo si una o ambas de las propiedades (nombre y valor) no están definidos pero también si el valor de uno o ambos se refiere a la cadena vacía, nulo, 0, NaN o falso.

Answer 9

Sería bueno obtener más información sobre el problema que está tratando de resolver.

No creo que haya un objeto en JavaScript llamado Struct, a menos que defina uno.

Creo que lo que está buscando es un objeto JavaScript en lugar de Struct. Hay varias formas de crear un objeto nuevo, y pueden anidarse en una matriz u otros objetos.

myArray[0] = new Object(); 
myArray[0].name = "parameter-name"; 
myArray[0].value = "parameter-value"; 

myArray[1] = new Object(); 
myArray[1].name = "parameter-name2"; 
myArray[1].value = "parameter-value2"; 

Tenga en cuenta que he cambiado el código en un par de maneras: 1. "matriz" se denomina "miMatriz" para aclarar que nos referimos a un conjunto particular. 2. La primera instancia de myArray es 0. Las matrices comienzan en 0 en Javascript. 3. Struct se cambia a Object.

myarray = [ 
    { 
     "name":"parameter-name", 
     "value":"parameter-value" 
    }, 
    { 
     "name":"parameter-name2", 
     "value":"parameter-value2" 
    } 
]; 

Esta es una sintaxis alternativa para hacer lo mismo. Utiliza "notación literal" para designar una matriz (los corchetes) y los objetos (las llaves).

for(var i = 0; i < myArray.length; i++) { 
    for(key in myArray[i]) { 
     alert(key + " :: " myArray[i][key]); 
    } 
} 

Esto recorrerá la matriz y le avisará para cada propiedad del objeto.

alert(myArray[0]['value']) //parameter-value 
myArray[0]['value'] = "bar"; 
alert(myArray[0]['value']) //bar 

A cada propiedad de cada objeto también se le puede asignar un nuevo valor.