Implementing String.prototype.startsWith in JavaScript

The startsWith() method is a built-in JavaScript function that determines whether a string begins with the characters of a specified string. Implementing this functionality yourself is a great exercise in string manipulation and understanding how built-in methods work under the hood. This challenge asks you to recreate this method as an extension to the String.prototype.

Problem Description

You are tasked with implementing a startsWith method directly on the String.prototype. This means all string instances in JavaScript will gain this new method. The startsWith method should take two arguments:

1. searchString: The string to search for at the beginning of the target string.
2. position: (Optional) The index within the target string at which to start the search. If omitted, the search begins at the first character (index 0).

The method should return true if the target string starts with the searchString, and false otherwise. The comparison should be case-sensitive.

Key Requirements:

• The implementation must be added to String.prototype.
• The method should handle the optional position argument correctly.
• The method should return a boolean value.
• The method should correctly handle edge cases (see below).

Expected Behavior:

The method should behave identically to the native String.prototype.startsWith() method.

Edge Cases to Consider:

• searchString is an empty string: Should always return true.
• position is greater than or equal to the length of the string: Should return false.
• position is negative: Should treat it as 0 (start at the beginning of the string).
• searchString is longer than the target string: Should return false.
• Both searchString and the target string are empty: Should return true.

Examples

Example 1:

Input: "Hello world".startsWith("Hello")
Output: true
Explanation: The string "Hello world" starts with "Hello".

Example 2:

Input: "Hello world".startsWith("world")
Output: false
Explanation: The string "Hello world" does not start with "world".

Example 3:

Input: "Hello world".startsWith("world", 6)
Output: true
Explanation: Starting the search at index 6, "Hello world" starts with "world".

Example 4:

Input: "Hello world".startsWith("world", 10)
Output: false
Explanation: Starting the search at index 10, "Hello world" does not start with "world".

Example 5:

Input: "Hello".startsWith("")
Output: true
Explanation: An empty string is a prefix of any string.

Example 6:

Input: "".startsWith("Hello")
Output: false
Explanation: An empty string cannot start with "Hello".

Constraints

• The searchString and the target string will be strings.
• The position argument, if provided, will be an integer.
• The time complexity of your solution should be O(n) where n is the length of searchString.
• The space complexity of your solution should be O(1).

Notes

Consider using string slicing or other string manipulation techniques to achieve the desired result. Remember that you are extending the String.prototype, so your code needs to be placed correctly to add the new method to all string instances. Think about how to handle the optional position argument and the various edge cases described above.