---
title: Avoid array and hash constructor when empty
description: Datadog, the leading service for cloud-scale monitoring.
breadcrumbs: >-
  Docs > Datadog Security > Code Security > Static Code Analysis (SAST) > SAST
  Rules > Avoid array and hash constructor when empty
---

# Avoid array and hash constructor when empty

{% callout %}
# Important note for users on the following Datadog sites: app.ddog-gov.com

{% alert level="danger" %}
This product is not supported for your selected [Datadog site](https://docs.datadoghq.com/getting_started/site.md). ().
{% /alert %}

{% /callout %}

## Metadata{% #metadata %}

**ID:** `ruby-best-practices/literal-hash-array`

**Language:** Ruby

**Severity:** Notice

**Category:** Best Practices

## Description{% #description %}

The rule "Avoid array and hash constructor when empty" is an important practice in Ruby for creating empty arrays and hashes. It dictates that developers should use literal constructors `[]` for arrays and `{}` for hashes rather than `Array.new` and `Hash.new` when the array or hash being created is empty.

This rule is important because it promotes code readability and simplicity. The literal constructors `[]` and `{}` are concise, straightforward, and are commonly used in the Ruby community. Using these instead of `Array.new` and `Hash.new` makes the code easier to read and understand.

To adhere to this rule, always use `[]` to initialize an empty array and `{}` to initialize an empty hash. However, it is acceptable to use `Array.new` and `Hash.new` when you are initializing an array or hash with default values, as demonstrated in the compliant code example.

## Non-Compliant Code Examples{% #non-compliant-code-examples %}

```ruby
# Use [] instead
foo = Array.new

# Use {} instead
bar = Hash.new
bar_block = Hash.new {  }

bar_with_parentheses = Array.new()
bar_block_with_parentheses = Hash.new() { }

# Empty brackets
foo_with_brackets = Array[]
bar_with_brackets = Hash[]
```

## Compliant Code Examples{% #compliant-code-examples %}

```ruby
foo = []
bar = {}

# Okay since they contain values
baz = Array.new(42)
qux = Hash.new(99)
barbaz = Array.new(24) {}

# Okay since this provides a default value
with_default = Hash.new { |hash, key| hash[key] = { object_name: key, digest: {}, updated: false } },

# Okay since this provides initial values
bar_brackets = Array[2, 1]
foo_brackets = Hash[:a, 1]
```
  Seamless integrations. Try Datadog Code SecurityDatadog Code Security 
{% icon name="icon-external-link" /%}