Angular 2 TypeScript cómo encontrar el elemento en la matriz

Tengo un componente y un servicio:

Componente:

export class WebUserProfileViewComponent {
    persons: Person [];
    personId: number;
    constructor( params: RouteParams, private personService: PersonService) {
          
        
           this.personId = params.get('id');
           this.persons =  this. personService.getPersons();
           console.log(this.personId);  
        }
}

Servicio:

@Injectable()
export class PersonService {
      getPersons(){
        var persons: Person[] = [
            {id: 1, firstName:'Hans', lastName:'Mustermann', email: '[email protected]', company:'Test', country:'DE'},
            {id: 2, firstName:'Muster', lastName:'Mustermann', email: '[email protected]', company:'test', country:'DE'},
            {id:3, firstName:'Thomas', lastName:'Mustermann', email: '[email protected]', company:'test', country:'DE'}
        ];
          
        return persons;
      }
}

Quiero obtener el elemento de persona con el Id ('personID'). La persona que obtengo de Routeparam. Para eso necesito el bucle foreach? Pero no he encontrado una solución para esto.

Necesitas usar el método Array.filter:

this.persons =  this.personService.getPersons().filter(x => x.id == this.personId)[0];

o Array.find

this.persons =  this.personService.getPersons().find(x => x.id == this.personId);

Supongamos que tengo debajo de la matriz:

Skins[
    {Id: 1, Name: "oily skin"}, 
    {Id: 2, Name: "dry skin"}
];

Si queremos obtener un artículo con Id = 1y Name = "oily skin", lo intentaremos de la siguiente manera:

var skinName = skins.find(x=>x.Id == "1").Name;

El resultado devolverá el skinName es "Skin graso".

Por favor, intente, gracias y un saludo!

Transforme la estructura de datos en un mapa si usa esta búsqueda con frecuencia

mapPersons: Map<number, Person>;

// prepare the map - call once or when person array change
populateMap() : void {
    this.mapPersons = new Map();
    for (let o of this.personService.getPersons()) this.mapPersons.set(o.id, o);
}
getPerson(id: number) : Person {
    return this.mapPersons.get(id);
}

Una buena opción que aún no se menciona es utilizar la combinación .findcon las funciones de flecha y la desestructuración. Tome este ejemplo de MDN .

const inventory = [
  {name: 'apples', quantity: 2},
  {name: 'bananas', quantity: 0},
  {name: 'cherries', quantity: 5}
];

const result = inventory.find( ({ name }) => name === 'cherries' );

console.log(result) // { name: 'cherries', quantity: 5 }

desde TypeScript puede usar el método nativo JS array filter ():

let filteredElements=array.filter(element => element.field == filterValue);

devuelve una matriz con solo elementos coincidentes de la matriz original (0, 1 o más)

Referencia: https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Use este código en su servicio:

return this.getReports(accessToken)
        .then(reports => reports.filter(report => report.id === id)[0]);

Prueba esto

          let val = this.SurveysList.filter(xi => {
        if (xi.id == parseInt(this.apiId ? '0' : this.apiId))
          return xi.Description;
      })

      console.log('Description : ', val );