**Course Title:** Ruby Programming: From Basics to Advanced Techniques **Section Title:** Data Structures: Arrays, Hashes, and Sets **Topic:** Common array and hash methods ### Introduction In the previous topics, we covered the basics of arrays and hashes in Ruby. In this topic, we will delve deeper into the common methods available for these data structures. Understanding these methods is crucial for efficient and effective programming in Ruby. ### Arrays Arrays are ordered collections of elements, and they are one of the most commonly used data structures in Ruby. Here are some common array methods: #### 1. `push` and `unshift` The `push` method adds an element to the end of the array, while the `unshift` method adds an element to the beginning of the array. ```ruby # Example usage: arr = [1, 2, 3] arr.push(4) puts arr # => [1, 2, 3, 4] arr.unshift(0) puts arr # => [0, 1, 2, 3, 4] ``` #### 2. `pop` and `shift` The `pop` method removes the last element from the array, while the `shift` method removes the first element from the array. ```ruby # Example usage: arr = [1, 2, 3] arr.pop puts arr # => [1, 2] arr.shift puts arr # => [2] ``` #### 3. `sort` and `reverse` The `sort` method sorts the array in ascending order, while the `reverse` method reverses the order of the array. ```ruby # Example usage: arr = [3, 1, 2] arr.sort! puts arr # => [1, 2, 3] arr.reverse! puts arr # => [3, 2, 1] ``` #### 4. `each` and `map` The `each` method allows you to iterate over the array, while the `map` method applies a block of code to each element in the array. ```ruby # Example usage: arr = [1, 2, 3] arr.each do |element| puts element end arr.map do |element| element * 2 end # => [2, 4, 6] ``` #### 5. `select` and `reject` The `select` method returns a new array containing only the elements that match the block, while the `reject` method returns a new array containing only the elements that do not match the block. ```ruby # Example usage: arr = [1, 2, 3, 4, 5] arr.select do |element| element % 2 == 0 end # => [2, 4] arr.reject do |element| element % 2 == 0 end # => [1, 3, 5] ``` ### Hashes Hashes are unordered collections of key-value pairs, and they are commonly used to store data in a structured way. Here are some common hash methods: #### 1. `key?` and `value?` The `key?` method checks if a key exists in the hash, while the `value?` method checks if a value exists in the hash. ```ruby # Example usage: hash = { name: 'John', age: 30 } hash.key?('name') # => true hash.key?('city') # => false hash.value?('name') # => 'John' hash.value?('city') # => nil ``` #### 2. `include?` and `exclude?` The `include?` method checks if a value exists in the hash, while the `exclude?` method checks if a value does not exist in the hash. ```ruby # Example usage: hash = { name: 'John', age: 30 } hash.include?('name') # => true hash.include?('city') # => false hash.exclude?('city') # => true hash.exclude?('name') # => false ``` #### 3. `merge` and `merge!` The `merge` method merges two hashes into one, while the `merge!` method merges two hashes into one and returns the new hash. ```ruby # Example usage: hash1 = { name: 'John', age: 30 } hash2 = { city: 'New York', country: 'USA' } hash1.merge(hash2) # => { name: 'John', age: 30, city: 'New York', country: 'USA' } hash1.merge!(hash2) # => { name: 'John', age: 30, city: 'New York', country: 'USA' } ``` #### 4. `delete` and `delete_key` The `delete` method removes the first occurrence of a key-value pair from the hash, while the `delete_key` method removes a key from the hash. ```ruby # Example usage: hash = { name: 'John', age: 30 } hash.delete('name') # => 'John' hash.delete('city') # => nil hash.delete_key('name') # => nil ``` ### Practical Takeaways * Use `push` and `unshift` to add elements to the beginning and end of an array, respectively. * Use `pop` and `shift` to remove elements from the end and beginning of an array, respectively. * Use `sort` and `reverse` to sort and reverse an array, respectively. * Use `each` and `map` to iterate over and transform an array, respectively. * Use `select` and `reject` to filter an array, respectively. * Use `key?` and `value?` to check if a key or value exists in a hash, respectively. * Use `include?` and `exclude?` to check if a value exists or does not exist in a hash, respectively. * Use `merge` and `merge!` to merge two hashes into one, respectively. * Use `delete` and `delete_key` to remove elements from a hash, respectively. ### Additional Resources * Ruby documentation: [Arrays](https://ruby-doc.org/core-3.1.0/doc/syntax/collections_rdoc.html#label-Arrays) and [Hashes](https://ruby-doc.org/core-3.1.0/doc/syntax/collections_rdoc.html#label-Hashes) * Ruby tutorials: [Arrays](https://ruby-tutorials.com/ruby-tutorial/ruby-arrays/) and [Hashes](https://ruby-tutorials.com/ruby-tutorial/ruby-hashes/) ### Leave a Comment or Ask for Help Do you have any questions or need further clarification on any of the topics covered in this topic? Please leave a comment below, and I'll do my best to assist you.