{"id":11,"date":"2026-07-15T07:00:00","date_gmt":"2026-07-15T07:00:00","guid":{"rendered":"https:\/\/example.com\/?p=2"},"modified":"2026-07-15T07:00:00","modified_gmt":"2026-07-15T07:00:00","slug":"most-important-javascript-lessons-from-the-last-two-weeks","status":"publish","type":"post","link":"https:\/\/bassettgraphics.com\/blog\/2026\/07\/15\/most-important-javascript-lessons-from-the-last-two-weeks\/","title":{"rendered":"Most Important JavaScript Lessons From the Last Two Weeks"},"content":{"rendered":"<p>Over the last two weeks, I have been practicing JavaScript by solving challenges on Codewars. Many of my solutions worked, but I often solved problems using longer loops and multiple conditions before realizing that JavaScript already had methods that could express the same logic more clearly.<\/p>\n<p>Two methods that stood out to me were:<\/p>\n<ul>\n<li><code>.some()<\/code><\/li>\n<li><code>.sort()<\/code><\/li>\n<\/ul>\n<p>Learning these methods showed me that improving as a programmer is not only about getting the correct answer. It is also about learning how to make code shorter, clearer, and easier to understand.<\/p>\n<p><!--more--><\/p>\n<h2>What I Learned From Solving Codewars Kata<\/h2>\n<p>Before learning more about array methods, I often approached challenges by manually building the entire solution.<\/p>\n<p>My usual process involved:<\/p>\n<ol>\n<li>Creating an empty array.<\/li>\n<li>Writing one or more <code>for<\/code> loops.<\/li>\n<li>Comparing values with several <code>if<\/code> and <code>else if<\/code> statements.<\/li>\n<li>Adding values to a new array with <code>.push()<\/code>, <code>.unshift()<\/code>, or <code>.splice()<\/code>.<\/li>\n<li>Keeping track of additional variables, indexes, or flags.<\/li>\n<\/ol>\n<p>This approach helped me understand how the logic worked internally. Even when my solution was longer than necessary, writing it manually taught me how values move through a loop and how conditions control a program.<\/p>\n<p>However, I also learned that many JavaScript array methods already contain common looping behavior.<\/p>\n<h2>Lesson One: Using <code>.some()<\/code><\/h2>\n<p>The <code>.some()<\/code> method checks whether <strong>at least one element<\/strong> in an array passes a test.<\/p>\n<p>The general syntax is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">array<\/span><span class=\"p\">.<\/span><span class=\"nx\">some<\/span><span class=\"p\">((<\/span><span class=\"nx\">element<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"nx\">condition<\/span><span class=\"p\">;<\/span>\n<span class=\"p\">});<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The method returns a Boolean value:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kc\">true<\/span>\n<\/code><\/pre>\n<\/div>\n<p>or:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kc\">false<\/span>\n<\/code><\/pre>\n<\/div>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">numbers<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"mf\">2<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">4<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">7<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">10<\/span><span class=\"p\">];<\/span>\n\n<span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">hasOddNumber<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"nx\">numbers<\/span><span class=\"p\">.<\/span><span class=\"nx\">some<\/span><span class=\"p\">((<\/span><span class=\"nx\">number<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"nx\">number<\/span><span class=\"w\"> <\/span><span class=\"o\">%<\/span><span class=\"w\"> <\/span><span class=\"mf\">2<\/span><span class=\"w\"> <\/span><span class=\"o\">!==<\/span><span class=\"w\"> <\/span><span class=\"mf\">0<\/span><span class=\"p\">;<\/span>\n<span class=\"p\">});<\/span>\n\n<span class=\"nx\">console<\/span><span class=\"p\">.<\/span><span class=\"nx\">log<\/span><span class=\"p\">(<\/span><span class=\"nx\">hasOddNumber<\/span><span class=\"p\">);<\/span>\n<span class=\"c1\">\/\/ true<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The result is <code>true<\/code> because the array contains at least one odd number: <code>7<\/code>.<\/p>\n<h3>Understanding the Callback Parameter<\/h3>\n<p>In this example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">numbers<\/span><span class=\"p\">.<\/span><span class=\"nx\">some<\/span><span class=\"p\">((<\/span><span class=\"nx\">number<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"nx\">number<\/span><span class=\"w\"> <\/span><span class=\"o\">%<\/span><span class=\"w\"> <\/span><span class=\"mf\">2<\/span><span class=\"w\"> <\/span><span class=\"o\">!==<\/span><span class=\"w\"> <\/span><span class=\"mf\">0<\/span><span class=\"p\">;<\/span>\n<span class=\"p\">});<\/span>\n<\/code><\/pre>\n<\/div>\n<p>the variable <code>number<\/code> is created as a parameter of the callback function.<\/p>\n<p>JavaScript passes each array element into <code>number<\/code>, one at a time:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>First test:\n\nnumber = 2\n\n2 % 2 !== 0\n\nfalse\n<\/code><\/pre>\n<\/div>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Second test:\n\nnumber = 4\n\n4 % 2 !== 0\n\nfalse\n<\/code><\/pre>\n<\/div>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Third test:\n\nnumber = 7\n\n7 % 2 !== 0\n\ntrue\n<\/code><\/pre>\n<\/div>\n<p>As soon as <code>.some()<\/code> finds a result that is <code>true<\/code>, it can stop checking and return:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kc\">true<\/span>\n<\/code><\/pre>\n<\/div>\n<h2>How I Used <code>.some()<\/code> in a Codewars Solution<\/h2>\n<p>One Codewars challenge required determining whether two characters had at least one possible replacement letter in common.<\/p>\n<p>Each character could be changed to the letter immediately before or after it in the alphabet.<\/p>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>d \u2192 c or e\n<\/code><\/pre>\n<\/div>\n<p>A helper function returned the possible choices:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">function<\/span><span class=\"w\"> <\/span><span class=\"nx\">getChoices<\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">alphabet<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;abcdefghijklmnopqrstuvwxyz&quot;<\/span><span class=\"p\">;<\/span>\n<span class=\"w\">  <\/span><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">index<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"nx\">alphabet<\/span><span class=\"p\">.<\/span><span class=\"nx\">indexOf<\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"p\">);<\/span>\n\n<span class=\"w\">  <\/span><span class=\"k\">if<\/span><span class=\"w\"> <\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"w\"> <\/span><span class=\"o\">===<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;a&quot;<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">    <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"s2\">&quot;b&quot;<\/span><span class=\"p\">];<\/span>\n<span class=\"w\">  <\/span><span class=\"p\">}<\/span>\n\n<span class=\"w\">  <\/span><span class=\"k\">if<\/span><span class=\"w\"> <\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"w\"> <\/span><span class=\"o\">===<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;z&quot;<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">    <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"s2\">&quot;y&quot;<\/span><span class=\"p\">];<\/span>\n<span class=\"w\">  <\/span><span class=\"p\">}<\/span>\n\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span>\n<span class=\"w\">    <\/span><span class=\"nx\">alphabet<\/span><span class=\"p\">[<\/span><span class=\"nx\">index<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"mf\">1<\/span><span class=\"p\">],<\/span>\n<span class=\"w\">    <\/span><span class=\"nx\">alphabet<\/span><span class=\"p\">[<\/span><span class=\"nx\">index<\/span><span class=\"w\"> <\/span><span class=\"o\">+<\/span><span class=\"w\"> <\/span><span class=\"mf\">1<\/span><span class=\"p\">]<\/span>\n<span class=\"w\">  <\/span><span class=\"p\">];<\/span>\n<span class=\"p\">}<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The following code checked whether at least one value from <code>leftChoices<\/code> also appeared in <code>rightChoices<\/code>:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">hasMatchingChoice<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"nx\">leftChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">some<\/span><span class=\"p\">((<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">  <\/span><span class=\"nx\">rightChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">includes<\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span>\n<span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>At first, this line was difficult for me to understand because <code>letter<\/code> was not declared elsewhere in the main function.<\/p>\n<p>I learned that:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<\/code><\/pre>\n<\/div>\n<p>creates the callback parameter.<\/p>\n<p>The <code>.some()<\/code> method supplies each value from <code>leftChoices<\/code> to that parameter.<\/p>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">leftChoices<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"s2\">&quot;c&quot;<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;e&quot;<\/span><span class=\"p\">];<\/span>\n<span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">rightChoices<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"s2\">&quot;e&quot;<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;g&quot;<\/span><span class=\"p\">];<\/span>\n<\/code><\/pre>\n<\/div>\n<p>JavaScript effectively checks:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Is &quot;c&quot; included in [&quot;e&quot;, &quot;g&quot;]?\n\nfalse\n<\/code><\/pre>\n<\/div>\n<p>Then:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Is &quot;e&quot; included in [&quot;e&quot;, &quot;g&quot;]?\n\ntrue\n<\/code><\/pre>\n<\/div>\n<p>Because one matching value exists, <code>.some()<\/code> returns:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kc\">true<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The important lesson was that I did not need to manually write another loop to compare every value.<\/p>\n<h2>My Longer Approach Versus <code>.some()<\/code><\/h2>\n<p>A longer solution might look like this:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">let<\/span><span class=\"w\"> <\/span><span class=\"nx\">hasMatchingChoice<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"kc\">false<\/span><span class=\"p\">;<\/span>\n\n<span class=\"k\">for<\/span><span class=\"w\"> <\/span><span class=\"p\">(<\/span><span class=\"kd\">let<\/span><span class=\"w\"> <\/span><span class=\"nx\">i<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"mf\">0<\/span><span class=\"p\">;<\/span><span class=\"w\"> <\/span><span class=\"nx\">i<\/span><span class=\"w\"> <\/span><span class=\"o\">&lt;<\/span><span class=\"w\"> <\/span><span class=\"nx\">leftChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"p\">;<\/span><span class=\"w\"> <\/span><span class=\"nx\">i<\/span><span class=\"o\">++<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">if<\/span><span class=\"w\"> <\/span><span class=\"p\">(<\/span><span class=\"nx\">rightChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">includes<\/span><span class=\"p\">(<\/span><span class=\"nx\">leftChoices<\/span><span class=\"p\">[<\/span><span class=\"nx\">i<\/span><span class=\"p\">]))<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">    <\/span><span class=\"nx\">hasMatchingChoice<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"kc\">true<\/span><span class=\"p\">;<\/span>\n<span class=\"w\">    <\/span><span class=\"k\">break<\/span><span class=\"p\">;<\/span>\n<span class=\"w\">  <\/span><span class=\"p\">}<\/span>\n<span class=\"p\">}<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The shorter version is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">hasMatchingChoice<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"nx\">leftChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">some<\/span><span class=\"p\">((<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">  <\/span><span class=\"nx\">rightChoices<\/span><span class=\"p\">.<\/span><span class=\"nx\">includes<\/span><span class=\"p\">(<\/span><span class=\"nx\">letter<\/span><span class=\"p\">)<\/span>\n<span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>Both approaches perform similar work.<\/p>\n<p>The longer version helped me understand the process, while the <code>.some()<\/code> version communicates the purpose more directly:<\/p>\n<blockquote>\n<p>Does at least one left-side choice exist in the right-side choices?<\/p>\n<\/blockquote>\n<h2>Lesson Two: Using <code>.sort()<\/code><\/h2>\n<p>Another Codewars challenge required arranging student names according to two rules:<\/p>\n<ol>\n<li>Longer names should appear first.<\/li>\n<li>Names of equal length should appear in reverse alphabetical order.<\/li>\n<\/ol>\n<p>My original approach involved:<\/p>\n<ul>\n<li>Sorting the names alphabetically.<\/li>\n<li>Reversing the array.<\/li>\n<li>Finding the longest name.<\/li>\n<li>Creating a new array.<\/li>\n<li>Looping repeatedly through the original array.<\/li>\n<li>Adding names according to their lengths.<\/li>\n<li>Tracking the current target length.<\/li>\n<\/ul>\n<p>The longer approach helped me understand the sorting rules, but JavaScript&#8217;s <code>.sort()<\/code> method could handle both conditions with one comparison function.<\/p>\n<p>The shorter solution was:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">function<\/span><span class=\"w\"> <\/span><span class=\"nx\">lineupStudents<\/span><span class=\"p\">(<\/span><span class=\"nx\">students<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"nx\">students<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">trim<\/span><span class=\"p\">()<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">split<\/span><span class=\"p\">(<\/span><span class=\"sr\">\/\\s+\/<\/span><span class=\"p\">)<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">      <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">||<\/span>\n<span class=\"w\">      <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">);<\/span>\n<span class=\"p\">}<\/span>\n<\/code><\/pre>\n<\/div>\n<h2>Understanding the <code>.sort()<\/code> Comparison Function<\/h2>\n<p>The comparison function receives two values:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"c1\">\/\/ Compare a and b<\/span>\n<span class=\"p\">}<\/span>\n<\/code><\/pre>\n<\/div>\n<p>JavaScript uses the returned number to decide their order.<\/p>\n<p>The general rules are:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Negative number:\n\na comes before b\n<\/code><\/pre>\n<\/div>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Positive number:\n\nb comes before a\n<\/code><\/pre>\n<\/div>\n<div class=\"codehilite\">\n<pre><span><\/span><code>Zero:\n\na and b are considered equal according to this comparison\n<\/code><\/pre>\n<\/div>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">numbers<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span><span class=\"mf\">5<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">2<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">10<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">1<\/span><span class=\"p\">];<\/span>\n\n<span class=\"nx\">numbers<\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">);<\/span>\n\n<span class=\"nx\">console<\/span><span class=\"p\">.<\/span><span class=\"nx\">log<\/span><span class=\"p\">(<\/span><span class=\"nx\">numbers<\/span><span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The result is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">[<\/span><span class=\"mf\">1<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">2<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">5<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">10<\/span><span class=\"p\">]<\/span>\n<\/code><\/pre>\n<\/div>\n<p>For descending order:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">numbers<\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The result is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">[<\/span><span class=\"mf\">10<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">5<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">2<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"mf\">1<\/span><span class=\"p\">]<\/span>\n<\/code><\/pre>\n<\/div>\n<h2>Sorting Names by Length<\/h2>\n<p>The first part of the Codewars comparison was:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<\/code><\/pre>\n<\/div>\n<p>This sorts longer names before shorter names.<\/p>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">names<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Ryan&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Alexander&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Sam&quot;<\/span>\n<span class=\"p\">];<\/span>\n\n<span class=\"nx\">names<\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">  <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<span class=\"p\">);<\/span>\n\n<span class=\"nx\">console<\/span><span class=\"p\">.<\/span><span class=\"nx\">log<\/span><span class=\"p\">(<\/span><span class=\"nx\">names<\/span><span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The result is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">[<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Alexander&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Ryan&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;Sam&quot;<\/span>\n<span class=\"p\">]<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The comparison uses the difference between the lengths.<\/p>\n<p>If:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">a<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;Ryan&quot;<\/span><span class=\"p\">;<\/span>\n<span class=\"nx\">b<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"s2\">&quot;Alexander&quot;<\/span><span class=\"p\">;<\/span>\n<\/code><\/pre>\n<\/div>\n<p>then:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<\/code><\/pre>\n<\/div>\n<p>becomes:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>9 - 4\n<\/code><\/pre>\n<\/div>\n<p>which returns:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>5\n<\/code><\/pre>\n<\/div>\n<p>Because the result is positive, <code>b<\/code> is placed before <code>a<\/code>.<\/p>\n<h2>Understanding the <code>||<\/code> Operator in the Sort Function<\/h2>\n<p>The complete comparison was:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">||<\/span>\n<span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The logical OR operator, <code>||<\/code>, allows the second sorting rule to run when the first comparison returns <code>0<\/code>.<\/p>\n<p>If two names have different lengths:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<\/code><\/pre>\n<\/div>\n<p>returns a nonzero number, and JavaScript uses that result.<\/p>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>8 - 5 = 3\n<\/code><\/pre>\n<\/div>\n<p>Because <code>3<\/code> is truthy, JavaScript stops evaluating the expression and uses <code>3<\/code> as the comparison result.<\/p>\n<p>If two names have the same length:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<\/code><\/pre>\n<\/div>\n<p>returns:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>0\n<\/code><\/pre>\n<\/div>\n<p>Because <code>0<\/code> is falsy, JavaScript continues to the expression after <code>||<\/code>:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>This applies the second sorting rule.<\/p>\n<p>The expression:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">||<\/span>\n<span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>can be thought of as:<\/p>\n<blockquote>\n<p>Sort by length first. If the lengths are equal, sort in reverse alphabetical order.<\/p>\n<\/blockquote>\n<h2>Understanding <code>b.localeCompare(a)<\/code><\/h2>\n<p>The <code>.localeCompare()<\/code> method compares strings alphabetically.<\/p>\n<p>Normally:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>can be used to sort strings in ascending alphabetical order:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>a \u2192 z\n<\/code><\/pre>\n<\/div>\n<p>Reversing the comparison:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>sorts the strings in descending alphabetical order:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>z \u2192 a\n<\/code><\/pre>\n<\/div>\n<p>For names of equal length, this produces the reverse alphabetical ordering required by the challenge.<\/p>\n<p>For example:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">const<\/span><span class=\"w\"> <\/span><span class=\"nx\">names<\/span><span class=\"w\"> <\/span><span class=\"o\">=<\/span><span class=\"w\"> <\/span><span class=\"p\">[<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxa&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxc&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxb&quot;<\/span>\n<span class=\"p\">];<\/span>\n\n<span class=\"nx\">names<\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">  <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<span class=\"p\">);<\/span>\n\n<span class=\"nx\">console<\/span><span class=\"p\">.<\/span><span class=\"nx\">log<\/span><span class=\"p\">(<\/span><span class=\"nx\">names<\/span><span class=\"p\">);<\/span>\n<\/code><\/pre>\n<\/div>\n<p>The result is:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">[<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxc&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxb&quot;<\/span><span class=\"p\">,<\/span>\n<span class=\"w\">  <\/span><span class=\"s2\">&quot;xxa&quot;<\/span>\n<span class=\"p\">]<\/span>\n<\/code><\/pre>\n<\/div>\n<h2>The Complete Short Solution<\/h2>\n<p>The final solution can be written as:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"kd\">function<\/span><span class=\"w\"> <\/span><span class=\"nx\">lineupStudents<\/span><span class=\"p\">(<\/span><span class=\"nx\">students<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">{<\/span>\n<span class=\"w\">  <\/span><span class=\"k\">return<\/span><span class=\"w\"> <\/span><span class=\"nx\">students<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">trim<\/span><span class=\"p\">()<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">split<\/span><span class=\"p\">(<\/span><span class=\"sr\">\/\\s+\/<\/span><span class=\"p\">)<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">((<\/span><span class=\"nx\">a<\/span><span class=\"p\">,<\/span><span class=\"w\"> <\/span><span class=\"nx\">b<\/span><span class=\"p\">)<\/span><span class=\"w\"> <\/span><span class=\"p\">=&gt;<\/span>\n<span class=\"w\">      <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">||<\/span>\n<span class=\"w\">      <\/span><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<span class=\"w\">    <\/span><span class=\"p\">);<\/span>\n<span class=\"p\">}<\/span>\n<\/code><\/pre>\n<\/div>\n<p>Each method has a separate purpose.<\/p>\n<h3><code>.trim()<\/code><\/h3>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">.<\/span><span class=\"nx\">trim<\/span><span class=\"p\">()<\/span>\n<\/code><\/pre>\n<\/div>\n<p>removes extra whitespace from the beginning and end of the string.<\/p>\n<h3><code>.split(\/\\s+\/)<\/code><\/h3>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">.<\/span><span class=\"nx\">split<\/span><span class=\"p\">(<\/span><span class=\"sr\">\/\\s+\/<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>turns the string into an array.<\/p>\n<p>The regular expression:<\/p>\n<div class=\"codehilite\">\n<pre><span><\/span><code>\\s+\n<\/code><\/pre>\n<\/div>\n<p>means:<\/p>\n<ul>\n<li><code>\\s<\/code> matches whitespace.<\/li>\n<li><code>+<\/code> means one or more occurrences.<\/li>\n<\/ul>\n<p>This allows the solution to handle one or more spaces between names.<\/p>\n<h3><code>.sort()<\/code><\/h3>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"p\">.<\/span><span class=\"nx\">sort<\/span><span class=\"p\">(...)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>sorts the names using the challenge&#8217;s two rules.<\/p>\n<h3><code>b.length - a.length<\/code><\/h3>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span><span class=\"w\"> <\/span><span class=\"o\">-<\/span><span class=\"w\"> <\/span><span class=\"nx\">a<\/span><span class=\"p\">.<\/span><span class=\"nx\">length<\/span>\n<\/code><\/pre>\n<\/div>\n<p>places longer names before shorter names.<\/p>\n<h3><code>b.localeCompare(a)<\/code><\/h3>\n<div class=\"codehilite\">\n<pre><span><\/span><code><span class=\"nx\">b<\/span><span class=\"p\">.<\/span><span class=\"nx\">localeCompare<\/span><span class=\"p\">(<\/span><span class=\"nx\">a<\/span><span class=\"p\">)<\/span>\n<\/code><\/pre>\n<\/div>\n<p>places names of equal length in reverse alphabetical order.<\/p>\n<h2>Why Writing the Long Solution Was Still Valuable<\/h2>\n<p>My longer solutions were not wasted work.<\/p>\n<p>By manually using loops, conditions, indexes, <code>.push()<\/code>, <code>.unshift()<\/code>, and <code>.splice()<\/code>, I learned more about what JavaScript was doing behind methods such as <code>.some()<\/code> and <code>.sort()<\/code>.<\/p>\n<p>The shorter solutions became easier to understand because I had already worked through the underlying logic.<\/p>\n<p>I learned that there are two useful stages when solving programming challenges:<\/p>\n<ol>\n<li>Write a solution that I understand and that produces the correct result.<\/li>\n<li>Review the solution and look for built-in methods that express the same logic more clearly.<\/li>\n<\/ol>\n<p>The goal is not always to write the shortest possible code. Code should also be readable and understandable.<\/p>\n<p>A one-line solution is not automatically better if it is difficult to understand. However, built-in methods can often communicate the purpose of the code more clearly once I understand how they work.<\/p>\n<h2>My Main Takeaways<\/h2>\n<p>The most important JavaScript lessons I learned during the last two weeks were:<\/p>\n<ul>\n<li><code>.some()<\/code> checks whether at least one array element passes a condition.<\/li>\n<li>The callback parameter in <code>.some()<\/code> receives each array element automatically.<\/li>\n<li><code>.some()<\/code> can replace a manual loop when I only need to know whether one match exists.<\/li>\n<li><code>.some()<\/code> returns a Boolean value: <code>true<\/code> or <code>false<\/code>.<\/li>\n<li><code>.sort()<\/code> can use a comparison function to define custom ordering rules.<\/li>\n<li><code>b.length - a.length<\/code> sorts strings from longest to shortest.<\/li>\n<li><code>b.localeCompare(a)<\/code> sorts strings in reverse alphabetical order.<\/li>\n<li>The <code>||<\/code> operator can connect a primary sorting rule with a secondary sorting rule.<\/li>\n<li>Longer solutions can be useful for learning how an algorithm works.<\/li>\n<li>After finding a working solution, refactoring can make the code more concise and expressive.<\/li>\n<\/ul>\n<h2>Conclusion<\/h2>\n<p>Practicing Codewars challenges has helped me understand not only how to solve programming problems, but also how to recognize patterns that JavaScript&#8217;s built-in methods already handle.<\/p>\n<p>My original solutions used more loops, conditions, variables, and manual array operations. Learning <code>.some()<\/code> and <code>.sort()<\/code> showed me how those same ideas could be expressed with less code while still remaining readable.<\/p>\n<p>One of my most important lessons was that writing a longer solution is not necessarily a bad way to learn. Building the logic manually helped me understand what the shorter methods were doing internally.<\/p>\n<p>As I continue learning JavaScript, I want to focus on understanding both approaches: how to build the logic manually and how to recognize when a built-in method can simplify it.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>How my solutions to Codewars kata could have been shortened with .some() and .sort()<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[9],"tags":[11,10,13,12],"class_list":["post-11","post","type-post","status-publish","format-standard","hentry","category-javascript","tag-codewars","tag-javascript","tag-programming","tag-web-development"],"_links":{"self":[{"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/posts\/11","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/comments?post=11"}],"version-history":[{"count":0,"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/posts\/11\/revisions"}],"wp:attachment":[{"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/media?parent=11"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/categories?post=11"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/bassettgraphics.com\/blog\/wp-json\/wp\/v2\/tags?post=11"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}