One place for hosting & domains

      Arrays

      Python Arrays: What They Are and How to Use Them


      Python arrays provide an effective way to store multiple values of the same type in a single variable. In this tutorial, you learn what Python arrays are and how to use them, and the difference between Python lists and arrays. You also learn how to loop through an array, add and remove elements from an array, and how to combine the values stored in different arrays.

      What Are Arrays in Python?

      In Python, an array is an ordered collection of objects, all of the same type. These characteristics give arrays two main benefits. First, items in an array can be consistently identified by their index, or location, within the array. Second, items in an array are assured to be of the same type.

      When creating an array in Python, you must indicate the type of data to be stored. The available types are indicated using codes, which consist of the following:

      Type Code C Type Python Type Min. Bytes
      ‘b’ signed char int 1
      ‘B’ unsigned char int 1
      ‘u’ wchar_t Unicode character 2
      ‘h’ signed short int 2
      ‘H’ unsigned short int 2
      ‘i’ signed int int 2
      ‘I’ unsigned int int 2
      ‘l’ signed long int 4
      ‘L’ unsigned long int 4
      ‘q’ signed long long int 8
      ‘Q’ unsigned long long int 8
      ‘f’ float float 4
      ’d’ double float 8

      Generally, though, for arrays containing numbers, you can focus on using just two of the available codes. Use the i code for arrays containing integers. Use the d code for arrays containing floating point numbers.

      You can see an example showing how to use a code to initiate an array at the beginning of the
      How to Use Arrays in Python
      section of this guide.

      Python Arrays vs. Lists

      Often, people talking about arrays in Python are actually referring to
      Python lists
      . While lists and arrays share some similarities in Python, they are two distinct types of collections.

      The main difference between lists and arrays is that arrays constrain the object type it can store. Lists do not give you a way to limit the types of objects they contain. When using an array, you can be sure that it only contains the type that was specified upon creation.

      A single Python list can simultaneously store integers, strings, and dictionaries. You can even add more elements of still other types to an existing list. By contrast, elements in a Python array can only be of one type. An array of integers can only contain integers and can only have other integers added to it.

      Aside from this difference, however, you can generally navigate and modify arrays and lists in the same way. All of the operations detailed below for arrays, except for the array() function itself, can be applied to lists as well.

      How to Use Arrays in Python

      The next few sections of this guide show you how to work with arrays in Python. Python has a wide variety of operations that can help you effectively make use of arrays. The sections below demonstrate the most common operations you might need to perform on arrays.

      All of the examples to follow work off of a simple integer array created using the following Python code:

      from array import *
      example_array = array("i", [2, 4, 6, 8])
      

      Note

      The
      array module
      is not loaded by default in Python. Instead, you need to import the module to start working with arrays.

      There are two ways you can interact with the contents of an array: either through Python’s indexing notation or through looping. Each of these is covered in the sections that follow.

      Python Array Indices and Slices

      The individual elements of an array can be accessed using indices. Array indices begin at 0. This means that the first element of an array is assigned an index of 0, and each subsequent element’s index progresses from there.

      So, to access the first, second, and third elements of the example_array, you use the following index notation:

      example_array[0]
      
      2
      example_array[1]
      
      4
      example_array[2]
      
      6

      You can also use negative numbers as indices. When you use a negative number as an index, Python counts backwards through the array, starting with -1 as the last item in the array. The following example accesses the last value stored in example_array:

      example_array[-1]
      
      8

      Python supports more advanced indexing through its slice notation. Slicing allows you to select a range of elements from an array.

      The syntax for slice notation is the following:

      [start:stop:step]
      

      start defines the first index of the range and stop defines the last. The step portion is optional. It is used to define how many elements to progress through while moving over the range start and stop range. By default, the value of set is 1.

      The next example slices the range from index 0 through index 3. It progresses through this range using 2 steps at a time, meaning it skips every other item:

      example_array[0:3:2]
      
      array('i', [2, 6])

      Python’s slice notation is a powerful tool that can be used to perform many more complicated operations than demonstrated in this guide. To see more examples with in-depth explanations, check out our guides
      How to Slice and Index Strings in Python
      and
      Python Lists and How to Use Them
      . While these guides do not deal directly with Python arrays, the concepts apply equally well.

      Looping Over Array Elements

      Python arrays can be iterated over using for loops. This provides a convenient way to take an action on each element in an array. Each loop yields a variable — item in the example — corresponding to an element in the array:

      for item in example_array:
          print(item)
      

      The output returns the value of every element in the array.

      2
      4
      6
      8

      Using the enumerate function, you simultaneously loop through the elements and their indices:

      for i, item in enumerate(test_array):
          print(str(i + 1) + ": " + str(item))
      

      The enumerate() function returns the count of the current iteration (stored in the i variable) and the value of the current iteration (stored in the item variable). Since array indexes begin at 0, the statement inside the loop adds 1 to the value of the i counter to calculate the current index.

      1: 2
      2: 4
      3: 6
      4: 8

      The output returns the index number of the current element in the array along with the value itself. The index and the value are separated by a : as indicated in the enumerate() function’s print statement.

      Modifying Python Arrays

      Python also provides ways of modifying the contents of an array, whether you need to add elements or remove them. There is even a way to combine multiple arrays. These next sections show you how to do all of these operations, working with the same example array as above.

      Add an Element to an Array

      Python arrays include two built-in methods for adding new elements. Which method you use depends on where within the array you want the new element to be added.

      Use the append() method to add a new element to the end of an array. The example below adds the integer 10 as a new element at the end of example_array:

      example_array.append(10)
      print(example_array)
      

      The array example_array now also contains the 10 integer.

      array('i', [2, 4, 6, 8, 10])

      Use the insert() method to add a new element to a specific position within an array. The method accepts two parameters; the first parameter is the index where the element should be inserted and the second is the element to insert into the array.

      The example below uses the insert() method to place the integer 7 in example_array index position 3.

      example_array.insert(3, 7)
      print(example_array)
      

      Printing the array confirms that it now contains integer 7 in index position 3:

      array('i', [2, 4, 6, 7, 8, 10])

      Remove an Element from an Array

      Python arrays include two built-in methods that you can use to remove elements from an array. The method you choose depends on whether you want to remove an element based on a given value or a given index.

      The remove() method takes as a parameter the value to remove from the array. In the following example, the remove() method removes integer 7 from example_array. This integer was added to the array in the previous section.

      example_array.remove(7)
      print(example_array)
      

      The output confirms that example_array no longer contains 7.

      array('i', [2, 4, 6, 8, 10])

      The pop() method, on the other hand, can be used to remove elements based on index. This next example uses the -1 index to remove the last element in the array, which was one of the elements added in the previous section:

      example_array.pop(-1)
      print(example_array)
      
      10
      array('i', [2, 4, 6, 8])

      The pop() method returns the value of the element that has been removed. This is why the output displays the integer 10. This is useful if, for example, you want to store the value of the removed element in a new variable.

      Combining Arrays

      Python arrays can be combined, or concatenated, using the + operator. There are other ways to go about combining arrays — using a loop, for instance. But the + operator provides the most convenient method if your goal is simply to join two or more arrays.

      In the example below, the example_array is combined with a new array, another_array, and stored in combined_array.

      example_array = array("i", [2, 4, 6, 8])
      another_array = array("i", [20, 40, 60, 80])
      combined_array = example_array + another_array
      print(combined_array)
      

      Printing combined_array confirms that it now contains all the values stored in the two concatenated arrays.

      array('i', [2, 4, 6, 8, 20, 40, 60, 80])

      Conclusion

      Python arrays are a collection type that can store multiple values. Each value can be accessed using index notation. While a Python array is similar to a list, it differs in that you can only store values of the same type in an array. Arrays also have built-in methods that help you add and remove elements. You can also combine two arrays using the + operator.

      More Information

      You may wish to consult the following resources for additional information
      on this topic. While these are provided in the hope that they will be
      useful, please note that we cannot vouch for the accuracy or timeliness of
      externally hosted materials.



      Source link

      Grundlegendes zum Rendern von Arrays in React


      Einführung

      In diesem Artikel erfahren Sie, wie eine Anordnung in React gerendert wird und welche bewährten Verfahren beim Rendern verschiedener Elemente innerhalb von Komponenten anzuwenden sind.

      Einer der Vorteile der Verwendung einer modernen Websprache wie JavaScript ist, dass Sie die Erzeugung von HTML schnell automatisieren können.

      Wenn Sie so etwas wie eine Schleife gegen eine Anordnung oder ein Objekt verwenden, müssen Sie das HTML pro Element nur einmal schreiben.  Besser noch, alle zukünftigen Bearbeitungen müssen nur einmal angewendet werden.

      Rendern mehrerer Elemente

      Um mehrere JSX-Elemente in React zu rendern, können Sie eine Anordnung mit der .map() -Methode durchlaufen und ein einzelnes Element zurückgeben.

      Unten durchlaufen Sie die reptiles-Anordnung und geben ein li-Element für jedes Element in der Anordnung zurück. Sie können diese Methode verwenden, wenn Sie ein einzelnes Element für jedes Element in der Anordnung anzeigen möchten:

      function ReptileListItems() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return reptiles.map((reptile) => <li>{reptile}</li>);
      }
      

      Die Ausgabe sieht in etwa folgendermaßen aus:

      Output

      - alligator - snake - lizard

      Im nächsten Beispiel prüfen Sie, warum Sie einen eindeutigen key zu einer Liste von Elementen hinzufügen möchten, die von einer Anordnung gerendert werden.

      Rendern einer Sammlung von Elementen innerhalb einer Komponente

      In diesem Beispiel durchlaufen Sie eine Anordnung und erstellen wie im vorherigen Beispiel eine Reihe von Listenelementkomponenten.

      Zu Beginn aktualisieren Sie den Code, um die <ol>-Komponente zum Speichern der <li>-Elemente zu verwenden. Die <ol>-Komponente erstellt eine geordnete Liste der Elemente:

      function ReptileList() {
        const reptiles = ["alligator", "snake", "lizard"];
      
        return (
          <ol>
            {reptiles.map((reptile) => (
              <li>{reptile}</li>
            ))}
          </ol>
        );
      }
      

      Wenn Sie jedoch auf die Konsole schauen, sehen Sie eine Warnung, dass jedes untergeordnete Element in einer Anordnung oder einem Iterator einen eindeutigen Schlüssel haben sollte.

      Warnung in der Konsole

      Die Warnung erscheint, da Sie beim Versuch, eine Sammlung innerhalb einer Komponente zu rendern, einen key hinzufügen müssen.

      In React wird ein eindeutiger key verwendet, um zu bestimmen, welche der Komponenten in einer Sammlung neu gerendert werden müssen. Durch das Hinzufügen eines eindeutigen keys wird verhindert, dass React bei jeder Aktualisierung die gesamte Komponente neu rendern muss.

      In diesem Schritt rendern Sie mehrere Elemente in einer Komponente und fügen einen eindeutigen key hinzu. Aktualisieren Sie den Code so, dass er einen key für die Listenelemente beinhaltet, um die Warnung zu beheben:

      function ReptileList() {
        const reptiles = ['alligator', 'snake', 'lizard'];
      
        return (
          <ol>
            {reptiles.map(reptile => (
              <li key={reptile}>{reptile}</li>
            ))}
          </ol>
        );
      }
      
      

      Nachdem Sie nun einen key hinzugefügt haben, wird die Warnung nicht mehr in der Konsole angezeigt.

      Im nächsten Beispiel sehen Sie, wie Sie benachbarte Elemente rendern können, ohne auf einen üblichen Syntaxfehler zu stoßen.

      Rendern benachbarter Elemente

      Um mehr als ein Element in einer Komponente zu rendern, müssen Sie einen Wrapper um diese Elemente hinzufügen.

      In diesem Beispiel geben Sie zunächst eine Liste von Elementen zurück, ohne eine Schleife durch eine Anordnung zu bilden:

      function ReptileListItems() {
        return (
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        );
      }
      

      Dadurch erhalten Sie einen schweren Fehler in der Konsole:

      Schwerer Fehler von React für benachbarte JSX-Elemente

      Um diesen Fehler zu beheben, müssen Sie den Block von li-Elementen in einem Wrapper einpacken. Für eine Liste können Sie diese in ein ol oder ul packen:

      function ReptileListItems() {
        return (
        <ol>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
        </ol>
        );
      }
      

      Die angrenzenden <li>-Elemente werden jetzt in ein umschließendes Tag <ol> eingehüllt,und Sie werden keinen Fehler mehr sehen.

      Im nächsten Abschnitt werden Sie eine Liste mit Hilfe einer Fragment-Komponente in einem Wrapper rendern.

      Rendern benachbarter Elemente mit React.fragment

      Vor React v16.2 können Sie einen Block von Komponenten in ein <div>-Element einpacken. Dies würde zu einer Anwendung voller divs führen, die oft als “div soup” bezeichnet wird.

      Um dieses Problem zu beheben, hat React eine neue Komponente veröffentlicht, die als Fragment-Komponente bekannt ist:

      Wenn Sie eine Liste innerhalb eines umschließenden Tags rendern müssen, aber vermeiden möchten, dass Sie eine div benutzen, können Sie stattdessen React.Fragment verwenden:

      function ReptileListItems() {
        return (
        <React.Fragment>
           <li>alligator</li>
           <li>snake</li>
           <li>lizard</li>
        </React.Fragment>
        );
      }
      

      Der gerenderte Code enthält nur die li-Elemente, und die React.Fragment-Komponente wird nicht im Code angezeigt.

      JSX-Elemente innerhalb eines React.Fragment Wrapper gerendert

      Beachten Sie auch, dass mit React.fragment keine Notwendigkeit besteht, einen Schlüssel hinzuzufügen.

      Sie werden feststellen, dass das Schreiben von React.fragment mühsamer als das Hinzufügen einer <div> ist. Glücklicherweise hat das React-Team eine kürzere Syntax entwickelt, um diese Komponente zu repräsentieren. Sie können <> </> anstelle von <React.Fragment></React.Fragment> verwenden:

      function ReptileListItems() {
        return (
       <>
          <li>alligator</li>
          <li>snake</li>
          <li>lizard</li>
       </>
        );
      }
      

      Zusammenfassung

      In diesem Artikel haben Sie verschiedene Beispiele für das Rendern von Anordnungen in einer React-Anwendung untersucht.

      Wenn Sie ein Element innerhalb einer anderen Komponente rendern, sollten Sie einen eindeutigen key verwenden und Ihre Elemente innerhalb eines Wrappers umfassen.

      Je nach Anwendungsfall können Sie einfache Listen erstellen, die in eine Fragment-Komponente gepackt werden und keinen Schlüssel benötigen.

      Um mehr über bewährte Praktiken in React zu erfahren, folgen Sie der vollständigen Reihe Wie man in React.js codiert auf DigitalOcean.



      Source link

      Vier Methoden zum Durchsuchen von Arrays in JavaScript


      In JavaScript gibt es viele nützliche Möglichkeiten, Elemente in Arrays zu finden. Sie könnten jederzeit auf die Basisschleife zurückgreifen, aber mit ES6+ gibt es eine Vielzahl von Methoden, um das Array in einer Schleife zu durchlaufen und das Gewünschte mit Leichtigkeit zu finden.

      Welche Methode wenden Sie bei so vielen verschiedenen Methoden an und in welchem Fall?  Wenn Sie zum Beispiel ein Array durchsuchen, möchten Sie wissen, ob das Element überhaupt in dem Array enthalten ist?  Benötigen Sie den Index des Elements oder das Element selbst?

      Bei jeder der verschiedenen Methoden, die wir behandeln werden, ist es wichtig zu verstehen, dass es sich bei allen um integrierte Methoden auf dem Array.Prototyp handelt. Das bedeutet, dass Sie sie einfach auf ein beliebiges Array mit Punktnotation verketten müssen.  Das bedeutet auch, dass diese Methoden nicht für Objekte oder etwas anderes als Arrays verfügbar sind (obwohl es Überschneidungen mit Strings gibt).

      Wir sehen uns die folgenden Array-Methoden an:

      beinhaltet

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.includes("thick scales"); // returns true
      

      Die .beinhaltet-Methode gibt einen booleschen Wert zurück und ist ideal, um Ihnen mitzuteilen, ob ein Element in einem Array existiert oder nicht.  Sie gibt eine einfache wahre oder falsche Antwort. Dies ist die grundlegende Syntax:

      arr.includes(valueToFind, [fromIndex]);
      

      Wie Sie in unserem Beispiel sehen, hatten wir nun nur einen Parameter – den valueToFind. Dies ist der Wert, der im Array übereinstimmt. Der optionale fromIndex ist eine Zahl, die anzeigt, welchen Index Sie mit der Suche beginnen möchten, (Standardwert ist 0, das gesamte Array wird durchsucht). Da das Element „thick scales“ also bei dem Index 0 liegt, wäre das folgende falsch: alligator.includes('thick scales', 1); , da es bei Index 1 und weiter mit der Suche beginnt.

      Jetzt gibt es einige wichtige Dinge zu beachten. Diese .beinhaltet() -Methode verwendet einen strengen Vergleich. Das bedeutet, dass aus dem obigen Beispiel Folgendes falsch zurückgegeben werden würde: alligator.includes('80'); das liegt daran, dass, obwohl 80 == '80' wahr ist, 80 === ‘80’ falsch ist – verschiedene Typen werden einem strengen Vergleich nicht standhalten.“

      find

      Wie unterscheidet sich .find() von der beinhaltet() Methode? Wenn wir in unserem Beispiel nur den Text „beinhaltet“ in „finden“ geändert haben, würden wir diesen Fehler erhalten:

      Uncaught TypeError: thick scales is not a function
      

      Das liegt daran, dass bei der Find-Methode eine Funktion übergeben werden muss.  Das liegt daran, dass die Suchmethode nicht einfach den einfachen Vergleichsoperator wie “beinhaltet()” verwenden wird. Stattdessen übergibt es jedes Element an Ihre Funktion und prüft, ob es wahr oder falsch zurückgibt.  Obwohl dies also funktioniert: alligator.find(() => 'thick scales'); würden Sie wahrscheinlich Ihren eigenen Vergleichsoperator in die Funktion setzen wollen, damit er alles Relevante zurückgibt.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.find(el => el.length < 12); // returns '4 foot tail'
      

      Diese einfache Funktion in unserer Finden-Methode betrachtet jedes Element des Arrays mit dem Alias ‘el’, den wir ihm zugewiesen haben, und hält an, wenn das erste gefunden wurde, das wahr ist.  In unserem Fall hat wahr eine Längeneigenschaft von weniger als 12 (Zahlen haben keine Längeneigenschaft). Sie könnten diese Funktion natürlich so komplex gestalten wie Sie sie benötigen, so dass Ihr wahrer Zustand Ihren Anforderungen entspricht.

      Beachten Sie auch, dass dies nicht wahr zurückgegeben wurde. Die Finden-Methode gibt keinen Booleschen Wert zurück, sondern das erste übereinstimmende Element. Wenn es kein übereinstimmendes Element gibt, da es nichts gibt, das die in Ihrer Funktion definierten Kriterien erfüllt, wird es als undefined zurückgegeben. Beachten Sie auch, dass es das erste zurückgibt, wenn also mehr als ein Element im Array vorhanden ist, das den Kriterien entspricht, wird es nur die erste Instanz erhalten. Wenn es in unserem Beispiel eine weitere Zeichenfolge von Länge unter 12 nach „4 Fuß hoch“ gab, würde dies unser Ergebnis nicht ändern.

      In unserem Beispiel haben wir den Rückruf nur mit einem Parameter verwendet.  Sie können auch Parameter hinzufügen, um auf den Index des aktuellen Elements zu verweisen.  Ein weiterer Parameter kann das gesamte Array selbst sein, aber ich finde, dass dies selten verwendet wird. Hier ist ein Beispiel der Verwendung mit dem Index:

      alligator.find((el, idx) => typeof el === "string" && idx === 2); // returns '4 foot tall'
      

      Wir wissen, dass es in unserem Array 3 verschiedene Elemente gibt, die der ersten Bedingung entsprechen (typeof el === „string“). Wenn dies unsere Bedingung war, würde sie die erste zurückgeben, „thick scales“ . Der Unterschied ist jedoch, dass nur eine den Index von 2 hat und das ist „4 Fuß hoch“.

      Apropos Indizes, eine ähnliche Array-Methode ist .findIndex(). Diese Methode empfängt auch eine Funktion, aber wie Sie sich denken können, gibt sie den Index des übereinstimmenden Elements anstelle des Elements selbst zurück.

      indexOf

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout"];
      
      alligator.indexOf("rounded snout"); // returns 3
      

      Wie die .includes() Methode, verwendet .indexOf() einen strengen Vergleich , keine Funktion, wie wir bei der Methode .finden() gesehen haben. Aber im Gegensatz zu .includes() gibt es den Index des Elements zurück, anstatt einen Booleschen Wert. Sie können auch angeben, bei welchem Index im Array die Suche beginnen soll.

      Ich finde indexOf() sehr nützlich. Es ist schnell und einfach und kann Ihnen sagen, wo sich das Element im Array befindet und ob es existiert.  Wie wird Ihnen mitgeteilt, ob das Element existiert? Grundsätzlich können wir wissen, dass das Element existiert, wenn es eine positive Zahl zurückgibt, und wenn es -1 zurückgibt, wissen wir, dass das Element nicht existiert.

      alligator.indexOf("soft and fluffy"); // returns -1
      alligator.indexOf(80); // returns 1
      alligator.indexOf(80, 2); // returns -1
      

      Und wie Sie sehen können, obwohl wir die Methoden find() oder findIndex() erhalten können, um uns die gleichen Informationen zu geben, ist dies viel weniger zu schreiben. Wir brauchen keine Vergleichsfunktion zu schreiben, da sie bereits innerhalb der Methode indexOf liegt.

      Genau wie die anderen gibt indexOf() jetzt auch den Index des ersten gefundenen übereinstimmenden Elements zurück.  JavaScript gibt uns eine alternative Array-Methode .lastIndexOf(). Wie Sie sich denken können, macht dies dasselbe wie indexOf() aber ausgehend vom letzten Index des Arrays und in umgekehrter Reihenfolge. Sie können auch einen zweiten Parameter angeben, aber denken Sie daran, dass sich die Indexes nicht ändern, nur weil Sie eine andere Methode verwenden.

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.indexOf(80); // returns 1
      alligator.lastIndexOf(80); // returns 4
      alligator.indexOf(80, 2); // returns 4
      alligator.lastIndexOf(80, 4); // returns 4
      alligator.lastIndexOf(80, 3); // returns 1
      

      Bonus: filter

      const alligator = ["thick scales", 80, "4 foot tail", "rounded snout", 80];
      
      alligator.filter(el => el === 80); //returns [80, 80]
      

      Die filter()-Methode ist wie die find()-Methode, d. h. sie erfordert eine übermittelte Funktion und eine Bedingung für das, was zurückgegeben wird.  Der Hauptunterschied ist, dass filter() immer ein Array zurückgibt, auch wenn es nur ein übereinstimmendes Element gibt.  Aber sie gibt alle übereinstimmenden Elemente zurück, während find() nur die erste Übereinstimmung zurückgibt.

      Das Wichtige am Filter ist, dass er alle Elemente zurückgibt, die Ihren Kriterien entsprechen.  Es kann auch nur ich sein, aber ich kann mich täuschen, wenn ich denke: „Das sind die Elemente, die ich herausfiltern möchte”, wenn Sie in Wahrheit die Elemente angeben, die Sie hineinfiltern möchten.

      Zusammenfassung

      Die einfachste Methode, die ich verwende, wenn ich etwas suche, ist die find()-Methode, aber wie Sie sehen können, hängt das wirklich von Ihrem Fall ab.

      • Müssen Sie nur wissen, ob sie existiert?  Verwenden Sie .includes().
      • Müssen Sie das Element selbst besorgen?  Verwenden Sie .find() oder .filter() für mehrere Elemente.
      • Müssen Sie den Index des Elements finden? Verwenden Sie .indexOf() oder findIndex() für eine komplexere Suche.

      Die Arrays in den Beispielen waren hier sehr einfach. Sie können sich mit einem Array von Objekten konfrontiert sehen. Im Folgenden finden Sie einige sehr einfache Beispiele, um durch den Dschungel vernetzter Objekte zu navigieren:

      const jungle = [
        { name: "frog", threat: 0 },
        { name: "monkey", threat: 5 },
        { name: "gorilla", threat: 8 },
        { name: "lion", threat: 10 }
      ];
      
      // break the object down in order to use .includes() or .indexOf()
      const names = jungle.map(el => el.name); // returns ['frog', 'monkey', 'gorilla', 'lion']
      console.log(names.includes("gorilla")); // returns true
      console.log(names.indexOf("lion")); // returns 3 - which corresponds correctly assuming no sorting was done
      
      // methods we can do on the array of objects
      console.log(jungle.find(el => el.threat == 5)); // returns object - {name: "monkey", threat: 5}
      console.log(jungle.filter(el => el.threat > 5)); // returns array - [{name: "gorilla", threat: 8}, {name: 'lion', threat: 10}]
      



      Source link