If an array of strings, print. Otherwise assume as an
 array of hashes (sequences) that needs further analysis.
971552
def extract_hashes_and_print(array)
      array.each do |entry|
        if entry.is_a? String
          print_list entry
        else
          inspect_inner_hash entry
        end
      end
    end
536248
def encodingStrings( reverse = false )
      @encodingStrings  = [ {"&" => "&amp;" },  {"<" => "&lt;"} , {">" => "&gt;"}, {"'" => "&apos;"}, {"\"" => "&quot;" }  ] if @encodingStrings.nil?
      if block_given?
         if reverse
            @encodingStrings.reverse_each{ |s| s.each{|k,v| yield v,k } }
         else
            @encodingStrings.each{ |s| s.each{|k,v| yield k,v }  }
         end
      else
         @encodingStrings
      end
   end
775710
function print (msgArray) {
    var i
    for (i = 0; i < msgArray.length; i += 1) {
      console.log(msgArray[i])
    }
  }
412251
def output_hash
      if @output_hash.blank?
        @output_hash = {}
        self.input_array.each do |t|
          if t.kind_of?(Array) || t.kind_of?(ActiveRecord::Relation)
            t.each do |ar_object|
              recurse(ar_object)
            end
          else
            recurse(t)
          end
        end
      end
      @output_hash
    end
19176
function scanArray(array) {
    var length = array.length;
    var containsStream = false;

    for (var i = 0; i < length; i++) {
      if (isStream(array[i])) {
        containsStream = true;
        break;
      }
    }

    return containsStream;
  }
1249218
function arrayOfArraysOfStrings(a, checkLowerCase) {
    return check.array(a) && a.every(function (arr) {
      return check.arrayOfStrings(arr, checkLowerCase);
    });
  }
748434
def join(strings: Optional[Sequence[str]], separator: str = "") -> str:
    
    return separator.join(s for s in strings if s) if strings else ""
1150718
def output_mapping
      @output_mapping ||= (
        hash = {}
        case output
        when Array
          output.each do |path|
            hash[path] = format(path)
          end
        when String
          hash[output] = format(output)
        when Hash
          hash = output
        end
        hash
      )
    end
351724
function onAnagrams( error, hashes ) {
	var hash,
		len,
		i;
	if ( error ) {
		throw new Error( error );
	}
	// Print the individual results...
	len = hashes.length;
	for ( i = 0; i < len; i++ ) {
		console.log( resources[ i ] + '...' );
		console.log( hashes[ i ].get() );
		console.log( '\n' );
	}
	// Merge the hashes...
	hash = hashes[ 0 ].copy();
	hash.merge.apply( hash, hashes.slice( 1 ) );

	// Print the merged hash...
	console.log( 'Merged...' );
	console.log( hash.get() );
}
724660
function asRegExps(array) {
    var array = asArray(array), len = array.length;
    for (var i = 0; i < len; i++) {
        if (!(array[i] instanceof RegExp)) {
            array[i] = new RegExp(array[i]);
        }
    }
    return array;
}
1174762
def _listify(x):
    """"""
    if isinstance(x, string_types):
        return [x]
    elif isinstance(x, collections.Iterable):
        return x
    else:
        return [x]
1099778
private String[] parseStringArray(final String list) {
		StringTokenizer tokenizer = new StringTokenizer(list, ",", false);
		int length = tokenizer.countTokens();
		String[] arr = new String[length];

		for (int i = 0; tokenizer.hasMoreElements(); i++) {
			arr[i] = cleanSpaces(tokenizer.nextToken());
		}

		return arr;
	}
454549
def print_arrays(data, cols)
      formatted_list = cli.list(data, :uneven_columns_across, cols)
      cli.say(formatted_list)
    end
922610
def write_hashes(self, arr):
        
        length = len(arr)
        self.write_var_int(length)
        for item in arr:
            ba = bytearray(binascii.unhexlify(item))
            ba.reverse()
            self.write_bytes(ba)
1101582
def [](key)
      if hash.key?(key)           then hash[key]
      elsif hash.key?(key.to_sym) then hash[key.to_sym]
      elsif hash.key?(key.to_s)   then hash[key.to_s]
      end
    end
1044632
function(indexes) {
      var isArray, k, v;
      isArray = Array.isArray(indexes);
      if (!isArray) {
        indexes = [indexes];
      }
      indexes = (function() {
        var results;
        results = [];
        for (k in indexes) {
          v = indexes[k];
          results.push(`${k} ${v}`);
        }
        return results;
      })();
      if (isArray) {
        return indexes;
      } else {
        return indexes[0];
      }
    }
1158616
def _maybe_trim_strings(self, array, **keys):
        
        trim_strings = keys.get('trim_strings', False)
        if self.trim_strings or trim_strings:
            _trim_strings(array)