name is an Array
13107
def extract_suffix(name)
      return unless name && name.size >= 3

      (name.size - 1).downto(2) do |n|
        suff = nil

        Nameable::Latin::Patterns::SUFFIX.each_pair do |pretty, regex|
          suff = pretty if name[n] =~ regex
        end

        if name[n] =~ Nameable::Latin::Patterns::SUFFIX_ACADEMIC ||
           name[n] =~ Nameable::Latin::Patterns::SUFFIX_PROFESSIONAL ||
           name[n] =~ Nameable::Latin::Patterns::SUFFIX_GENERATIONAL_ROMAN
          suff = name[n].upcase.delete('.')
        end

        if !suff &&
           name.join != name.join.upcase &&
           name[n].length > 1 &&
           name[n] =~ Nameable::Latin::Patterns::SUFFIX_ABBREVIATION
          suff = name[n].upcase.delete('.')
        end

        if suff
          @suffix = @suffix ? "#{suff}, #{@suffix}" : suff
          name.delete_at(n)
        end
      end
    end
983340
def class_name(name, separator = '::', want_array = false)
    Manager.connection.class_name(name, separator, want_array)
  end
153466
function Name() {
    /**
     * The prefix value
     * @member
     */
    this.prefix = null;
    /**
     * The first value
     * @member
     */
    this.first = null;
    /**
     * The middle value
     * @member
     */
    this.middle = null;
    /**
     * The last value
     * @member
     */
    this.last = null;
    /**
     * The suffix value
     * @member
     */
    this.suffix = null;

}
962281
function isArrayLike (a) {
  if ('object' != typeof a)
    return false
  else if (null == a)
    return false
  else
    return Boolean( Array.isArray(a)
                    || null != a.length
                    || a[0] )
}
693047
function findSameInArray (array, compareIndex) {
  const sliders = [];

  array.forEach((value, index) => {
    if (value === array[compareIndex]) {
      sliders.push(index);
    }
  });

  return sliders;
}
1092116
function find(array, exp) {
  return (isArray(array) && isDefined(exp))
    //return the member and not an array like `first`
    ? findInArray(array, $parse(exp), false)
    : array;
}
172286
function(name) {
			if (!Array.isArray(name))
				name = [name];
			
			// split names and indexes
			var names = [], indexes = [];
			name.forEach(function(item) {
				if (typeof item === 'string') {
					names.push(item);
				} else if (typeof item === 'number') {
					indexes.push(item);
				}
			});
			
			return this.list().filter(function(attribute, i) {
				return ~indexes.indexOf(i) || ~names.indexOf(attribute.name());
			});
		}
274847
def array(self, name):
        
        if name in self._navigable:
            if isinstance(self._navigable[name], (list, tuple)):
                return self[name]
            else:
                raise NoArrayFoundError
        else:
            return ArrayOfTables(toml_file=self, name=name)
842488
function(list, name) {
    if (Object.prototype.toString.call(list) === '[object Array]' && Object.prototype.toString.call(name) === '[object String]') {
      for (var i = 0; i < list.length; i++) {
        if (list[i] === name) {
          return true;
        }
      }
    }
    return false;
  }
680379
function inarray (list, item) {
  list = Object.prototype.toString.call(list) === '[object Array]' ? list : []

  var idx = -1
  var end = list.length

  while (++idx < end) {
    if (list[idx] === item) return true
  }

  return false
}
367412
def getArraysByName(elem, name):
	
	name = StripArrayName(name)
	return elem.getElements(lambda e: (e.tagName == ligolw.Array.tagName) and (e.Name == name))
1162711
function(name) {
			if (typeof name === 'number') {
				return this.list()[name];
			}
			
			if (typeof name === 'string') {
				return utils.find(this.list(), function(prop) {
					return prop.name() === name;
				});
			}
			
			return name;
		}
381081
function ArrayindexOf(thing) {
  var index = 0;
  var count = this.length;
  while (index < count) {
    if (this[index] === thing) return index
    index = index + 1
  }
  return -1
}
1156566
def _name_value(self, s):
        """"""
        parts = s.split(b' ', 2)
        name = parts[0]
        if len(parts) == 1:
            value = None
        else:
            size = int(parts[1])
            value = parts[2]
            still_to_read = size - len(value)
            if still_to_read > 0:
                read_bytes = self.read_bytes(still_to_read)
                value += b'\n' + read_bytes[:still_to_read - 1]
        return (name, value)
925479
def tag_name(name, multiple = false, index = nil)
      sanitized_method_name = name.to_s.sub(/\?$/, "")

      case
      when @builder.object_name.empty?
        "#{sanitized_method_name}#{multiple ? "[]" : ""}"
      when index
        "#{@builder.object_name}[#{index}][#{sanitized_method_name}]#{multiple ? "[]" : ""}"
      else
        "#{@builder.object_name}[#{sanitized_method_name}]#{multiple ? "[]" : ""}"
      end
    end
1181955
def array name, values
      array_attrs = {
        'soapenc:arrayType' => "xsd:string[#{values.length}]",
        'xsi:type'          => 'wsdl:ArrayOfString'
      }
      builder.tag! name, array_attrs do |tag|
        values.each { |value| tag.item value }
      end
      self
    end
327407
function(a){
            if(!a || !this.isArray(a)) return; 

            var i = 0,start = 0,len = a.length;

            for(;i < len; i++){
             if(!this.isUndefined(a[i]) && !this.isNull(a[i]) && !(this.isEmpty(a[i]))){
              a[start]=a[i];
              start += 1;
            }
          }

          a.length = start;
          return a;
    }