Ruby Refactoring

Talk I gave at a WomenWhoCode #Algorithms event!

Transcript

1. Refactoring for Readability How to write code other people can understand Meredith Edwards @meredith_marg
2. But Whyyyy??
3. I’ll Tell you why! Learning opportunity Makes you look good Kindness
5. Here’s An Example problem: Check to see if a string has the same number of 'x's and 'o's. Your method must return true or false and be case insensitive. The string can contain any character.
6. Kinda Like This: XO("ooxx") => true XO("xooxx") => false XO("ooxXm") => true XO("zpzpzpp") => true // when no 'x' and 'o' is present should return true XO("zzoo") => false
7. And an Example solution: def XO(str) xo_array = str.downcase.split("").select { |x| x == "x" || x == "o" } x_array = xo_array.partition { |x| x == "x" }.first o_array = xo_array.partition { |x| x == "x" }.last x_array.size == o_array.size end
9. Refactoring Step #1: ANNotate! def XO(str) # downcase the string and split it into an array xo_array = str.downcase.split("").select { |x| x == "x" || x == "o" } ...
10. ANNotate! ... # make an array of all the x's and call it x_array x_array = xo_array.partition { |x| x == "x" }.first # make an array of all the o's and call it o_array o_array = xo_array.partition { |x| x == "x" }.last ...
11. ANNotate! ... # compare the size of x_array to o_array. return true if they're the same size, and false if they aren't. x_array.size == o_array.size end
12. Step #2: Gather all your steps 1. Downcase the string and split it into an array 2. Make an array of all the x's and call it x_array 3. Make an array of all the o's and call it o_array 4. Compare the size of x_array to o_array. Return true if they're the same size, and false if they aren't.
13. Step #3: Write Some new methods 1. Downcase the string and split it into an array def grab_xs_and_os(str) str.downcase.split("").select do |char| char == "x" || "o" end end
14. Step #3: Write Some new methods 2. Make an array of all the x’s def grab_xs(array) array.partition{ |char| char == "x" }.first end
15. Step #3: Write Some new methods 3. Make an array of all the o’s def grab_os(array) array.partition{ |char| char == "o" }.first end
16. Step #3: Write Some new methods 4. Compare the size of x_array to o_array. Return true if they're the same size, and false if they aren't. def same_num_of_xs_os?(x_array, o_array) x_array.size == o_array.size end
17. Step #4: put the pieces back together... def XO(str) xo_array = grab_xs_and_os(str) x_array = grab_xs(xo_array) o_array = grab_os(xo_array) same_num_of_xs_os?(x_array, o_array) end
18. Take a second look... def XO(str) xo_arr = grab_xs_and_os(str) x_arr = grab_xs(xo_arr) o_arr = grab_os(xo_arr) same_num_of_xs_os?(x_arr, o_arr) end
19. Why are we grabbing X’s twice ?? def XO(str) xo_array = grab_xs_and_os(str) x_array = grab_xs(xo_array) o_array = grab_os(xo_array) same_num_of_xs_os?(x_array, o_array) end
20. We are Also grabbing O’s twice ! Oh boy. def XO(str) xo_array = grab_xs_and_os(str) x_array = grab_xs(xo_array) o_array = grab_os(xo_array) same_num_of_xs_os?(x_array, o_array) end
21. Okay, Let’s Redefine ‘grab_xs’ def x_array(str) str.split("").select do |char| char == "x" || "X" end end
22. And ‘grab_os’ def o_array(str) str.split("").select do |char| char == "o" || "O" end end
23. Then use our new methods... def XO(str) x_array(str).size == o_array(str).size end def x_array(str) str.split("").select{|char|char == "x" || "X"} end def o_array(str) str.split("").select{|char|char == "o" || "O"} end
24. But wait… are we making this too complicated? Why do we even need to make arrays for x’s and o’s?? Why can’t we just count the number of x’s in the string and compare that count to the number of o’s in the string??
25. Hey, I think there’s a method for that! def XO(string) str = string.downcase str.count('x') == str.count('o') end
26. Oh, and let’s give our ‘xo’ method a better name def XO(string) str = string.downcase str.count('x') == str.count('o') end
27. Much Better ! def same_num_xs_and_os?(string) str = string.downcase str.count('x') == str.count('o') end
28. A little secret
29. This Always comes before
30. This :)
31. Meredith Edwards Please get in touch! I’d love to hear from you. email: meredith.edwards1771@gmail.com twitter: @meredith_marg website: medwards1771.github.io/