Create a function that accepts a string as input and outputs an array containing all the words in the input string.

Strings are a fundamental part of programming languages, and manipulating them is a common task. One common operation is to split a string into individual words. In this article, we will explore how to write a function that takes a string as input and returns an array of words.

This function can be useful in a variety of scenarios. For example, if you are working with natural language processing or text analysis, you may want to break down a sentence or paragraph into its constituent words. Additionally, if you are building a word game or a text-based application, you may need to process user input and extract the individual words.

Let’s dive into the code and see how this function can be implemented in different programming languages. We’ll start with some pseudocode to illustrate the basic logic, and then provide examples in popular languages such as JavaScript, Python, and Ruby.

The Problem

When working with strings in programming, it is often necessary to divide the string into separate words. This can be useful for various tasks, such as counting the number of words, performing word-based operations, or analyzing the text.

However, splitting a string into words can be challenging, especially when dealing with different text formats, punctuation marks, or special characters. It requires careful parsing and consideration of various edge cases.

To simplify this process, we need to design a function that takes a string as input and returns an array of words.

Input StringOutput Array
«Hello, world!»[«Hello», «world»]
«The quick brown fox»[«The», «quick», «brown», «fox»]
«Coding is fun!»[«Coding», «is», «fun»]

By developing a function that efficiently splits a string into words, we can streamline our coding process and avoid reinventing the wheel for every project that requires word analysis.

Step 1: Defining the Input

Before we can start writing the function, we need to define the input parameter. In this case, the input parameter is a string. The function will take this string as an argument and process it to return an array of words.

A string is a sequence of characters, such as «Hello World» or «The quick brown fox». It can contain alphanumeric characters, spaces, and symbols. To split the string into words, we can use spaces as delimiters.

For example, if we have the string «The quick brown fox», the function will return the array [«The», «quick», «brown», «fox»]. Each word is separated by a space, so we can split the string using the space character.

Defining the input parameter is important because it helps us understand what kind of data the function is expecting. By defining the input as a string, we can also specify any constraints or requirements for the input, such as the maximum length or the allowed characters.

Step 2: Designing the Function

Now that we understand the requirements of the problem, let’s start designing our function. We need to create a function that takes a string as input and returns an array of words present in the string.

To achieve this, we will break down the string into smaller units called words. We can do this by finding the spaces in the string and splitting it at those positions. This will give us an array of substrings, each representing a word in the original string.

Here is the high-level design of our getWords function:

  1. Create an empty array to store the words.
  2. Loop through each character in the string.
  3. If the current character is a space, it means we have found a word. Add the word to the array.
  4. Continue the loop until we have processed all the characters in the string.
  5. Return the array of words.

By following this design, we can easily extract all the words from the input string and return them as an array. Let’s now implement this design in code.

Step 3: Splitting the String

After removing any leading or trailing whitespace, the next step is to split the string into an array of words. This can be done using the built-in split() method in JavaScript.

The split() method takes a delimiter as an argument and separates the string into an array of substrings based on that delimiter. In this case, the delimiter will be a space character (‘ ‘).

Here’s an example:

const string = "Hello world!";

const words = string.split(' ');

After executing this code, the words array will contain ['Hello', 'world!']. Each element in the array represents a word from the original string.

It’s important to note that the split() method will split the string at every occurrence of the delimiter. So if the string contains multiple consecutive spaces, the resulting array will contain empty strings as elements. These empty strings can be easily filtered out using the filter() method.

Step 4: Storing the Words in an Array

Now that we have the string containing the sentence, we need to convert it into an array of words. This will allow us to easily access and manipulate each individual word.

To store the words in an array, we can use the split() method in JavaScript. The split() method takes a delimiter as an argument and splits the given string into an array of substrings at each occurrence of the delimiter.

In our case, the delimiter will be a space, as we want to split the sentence into separate words. Here is the code to achieve this:

function splitWords(sentence) {
var wordsArray = sentence.split(" ");
return wordsArray;

In the above code, the splitWords() function takes a sentence as a parameter. It uses the split() method to split the sentence into words, and stores the resulting array in the variable wordsArray. Finally, it returns the wordsArray.

Now that we have the words stored in an array, we can easily perform any operations or manipulations on them, such as counting the number of words, sorting them, or any other required tasks.

Step 5: Returning the Array

Now that we have created the array and added words to it, we need to return this array from our function. To do this, we can use the return keyword followed by the name of the array.

Here’s how the function will look now:

function getWords(str) {
var words = [];
// Split the string into an array of words
words = str.split(' ');
// Return the array of words
return words;

By using the return keyword, we are able to pass the array of words back to the code that called our function. This allows us to use the array later on or perform any additional operations on it.

It’s important to note that the return statement should always be the last statement in your function. Any code written after the return statement will not be executed.

Now that we have completed our function, we can use it to get an array of words from a given string.

// Call the getWords function and store the result in a variable
var result = getWords("Hello World");
// Display the array of words
// Output: ["Hello", "World"]

As shown in the example above, we can use the console.log() function to display the array of words in the JavaScript console.

Congratulations! You have successfully created a function that takes a string and returns an array of words.

Step 6: Handling Edge Cases

When writing a function that takes a string and returns an array of words, it’s important to consider and handle edge cases. Edge cases are the extreme or special input values that may cause unexpected behavior or errors in your function. By considering these edge cases, you can make your function more robust and ensure that it handles all possible scenarios.

One common edge case to consider is when the input string is empty or consists only of whitespace characters. In this case, your function should return an empty array, as there are no words to extract from the string.

Another edge case to handle is when the string contains punctuation or special characters. Depending on your requirements, you may choose to include or exclude these characters from the words array. You can use regular expressions or built-in string methods to remove or replace these characters before extracting the words.

It’s also important to consider edge cases related to language-specific rules or conventions. For example, in some languages, hyphenated words should be treated as separate words. You should ensure that your function handles these cases correctly.

Additionally, you should consider the performance implications of your function, especially if you expect it to handle large strings. Depending on the programming language you’re using, splitting a string into an array of words can be an expensive operation. You should test your function with large input strings to ensure it performs well.


  1. Handle the edge case of an empty input string by returning an empty array.
  2. Consider how to handle punctuation and special characters in the string.
  3. Be aware of language-specific rules, such as hyphenated words.
  4. Test the performance of your function with large input strings.

By taking these steps to handle edge cases, you can ensure that your function works correctly and reliably in all scenarios.

Example Usage

Here are some examples of how to use the function:

  • Input: «This is a sentence.»

    Output: [«This», «is», «a», «sentence»]

  • Input: «Hello, world!»

    Output: [«Hello,», «world!»]

  • Input: «I love coding.»

    Output: [«I», «love», «coding»]

Оцените статью