Best way to handle Error on basic Array

Question

val myArray = Array("1", "2")
val error = myArray(5)//throws an ArrayOutOfBoundsException

myArray has no fixed size, which explains why a call like performed on the above second line might happen.

First, I never really understood the reasons to use error handling for expected errors. Am I wrong to consider this practice as bad, resulting from poor coding skills or an inclination towards laziness?

What would be the best way to handle the above case?

What I am leaning towards: basic implementation (condition) to prevent accessing the data like depicted;
use Option;
use Try or Either;
use a try-catch block.

It's not really clear what you're asking for. Do you refer to the potential of an ArrayOutOfBoundsException if you would do myArray(5) ? If so, how to handle that will depend on context. You can always check size and avoid the exception. — maasg
– maasg, Commented Oct 28, 2016 at 7:08
For any code that can throw an exception, you should wrap it in a Try. Then you can do whatever you want with that Try. — sarveshseri
– sarveshseri, Commented Oct 28, 2016 at 7:12

maasg · Accepted Answer · 2016-10-28 11:04:04Z

1 Avoid addressing elements through index

Scala offers a rich set of collection operations that are applied to Arrays through ArrayOps implicit conversions. This lets us use combinators like map, flatMap, take, drop, .... on arrays instead of addressing elements by index.

2 Prevent access out of range

An example I've seen often when parsing CSV-like data (in Spark):

case class Record(id:String, name: String, address:String)
val RecordSize = 3
val csvData = // some comma separated data
val records = csvData.map(line => line.split(","))
                     .collect{case arr if (arr.size == RecordSize) => 
                              Record(arr(0), arr(1), arr(2))}

3 Use checks that fit in the current context

If we are using monadic constructs to compose access to some resource, use a fitting way of lift errors to the application flow: e.g. Imagine we are retrieving user preferences from some repository and we want the first one:

Option

def getUserById(id:ID):Option[User]
def getPreferences(user:User) : Option[Array[Preferences]]

val topPreference = for {
      user <- userById(id)
      preferences <- getPreferences(user)
      topPreference <- preferences.lift(0)
   } yield topPreference

(or even better, applying advice #1):

val topPreference = for {
      user <- userById(id)
      preferences <- getPreferences(user)
      topPreference <- preferences.headOption
   } yield topPreference

Try

def getUserById(id:ID): Try[User]
def getPreferences(user:User) : Try[Array[Preferences]]
val topPreference = for {
      user <- userById(id)
      preferences <- getPreferences(user)
      topPreference <- Try(preferences(0))
   } yield topPreference

As general guidance: Use the principle of least power. If possible, use error-free combinators: = array.drop(4).take(1) If all that matters is having an element or not, use Option If we need to preserve the reason why we could not find an element, use Try.

Let the types and context of the program guide you.

jwvh · Accepted Answer · 2016-10-28 08:19:42Z

1

If indexing myArray can be expected to error on occasion, then it sounds like Option would be the way to go.

myArray.lift(1)  // Option[String] = Some(2)
myArray.lift(5)  // Option[String] = None

You could use Try() but why bother if you already know what the error is and you're not interested in catching or reporting it?

edited Oct 28, 2016 at 8:19

answered Oct 28, 2016 at 8:14

jwvh

51.3k7 gold badges42 silver badges70 bronze badges

Comments

Nagarjuna Pamu · Accepted Answer · 2016-10-28 09:23:43Z

1

Use arr.lift (available in standard library) which returns Option instead of throwing exception.

if not use safely

Try to access the element safely to avoid accidentally throwing exceptions in middle of the code.

implicit class ArrUtils[T](arr: Array[T]) {
   import scala.util.Try
   def safely(index: Int): Option[T] = Try(arr(index)).toOption
}

Usage:

arr.safely(4)

REPL

scala> val arr = Array(1, 2, 3)
arr: Array[Int] = Array(1, 2, 3)

scala> implicit class ArrUtils[T](arr: Array[T]) {
   import scala.util.Try
   def safely(index: Int): Option[T] = Try(arr(index)).toOption
  }
defined class ArrUtils

scala> arr.safely(4)
res5: Option[Int] = None

scala> arr.safely(1)
res6: Option[Int] = Some(2)

edited Oct 28, 2016 at 9:23

answered Oct 28, 2016 at 7:46

Nagarjuna Pamu

14.8k3 gold badges24 silver badges41 bronze badges

Collectives™ on Stack Overflow

Best way to handle Error on basic Array

3 Answers 3

1 Avoid addressing elements through index

2 Prevent access out of range

3 Use checks that fit in the current context

Option

Try

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Avoid addressing elements through index

2 Prevent access out of range

3 Use checks that fit in the current context

Option

Try

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related