extract the content of a attribut

@param cfxdTag
@param attrName
@return attribute value
@throws EvaluatorException
325718
public static String getAttributeString(Tag tag, String attrName, String defaultValue) {
	Literal lit = getAttributeLiteral(tag, attrName, null);
	if (lit == null) return defaultValue;
	return lit.getString();
    }
38862
function getHTMLAttribute(node, attrName) {
	attrName = attrName.toLowerCase();
	return node && node.attributes.find(attr => attr.name.value.toLowerCase() === attrName);
}
695271
function(el, attrName) {
                    var prop = attr.map[attrName];
                    if (typeof prop === "string" && el[prop]) {
                        return el[prop];
                    }

                    return el.getAttribute(attrName);
                }
606372
public Attr getAttributeNodeNS(String namespaceURI, String localName)
  {

    error(XMLErrorResources.ER_FUNCTION_NOT_SUPPORTED);  //"getAttributeNodeNS not supported!");

    return null;
  }
705912
public String getAttributeString(ObjectName name, String attributeName) throws Exception {
		Object bean = getAttribute(name, attributeName);
		if (bean == null) {
			return null;
		} else {
			return ClientUtils.valueToString(bean);
		}
	}
1307827
@Override
	public String getAttribute(String name) {
		final String sourceMethod = "getAttribute"; //$NON-NLS-1$
		boolean isTraceLogging = log.isLoggable(Level.FINER);
		if (isTraceLogging) {
			log.entering(AggregatorExtension.class.getName(), sourceMethod, new Object[]{name});
		}
		String result = attributes.getProperty(name);
		if (result != null && aggregator != null) {
			result = aggregator.substituteProps(result);
		}
		if (isTraceLogging) {
			log.exiting(AggregatorExtension.class.getName(), sourceMethod, result);
		}
		return result;
	}
98611
def _extract(self, attribute) -> str:
        """"""
        attr_data = self.journey.JourneyAttributeList.JourneyAttribute[
            self.attr_types.index(attribute)
        ].Attribute
        attr_variants = attr_data.xpath("AttributeVariant/@type")
        data = attr_data.AttributeVariant[attr_variants.index("NORMAL")].Text.pyval
        return str(data)
1057996
function getAttribute(babelTypes, attributes, name) { // {{{
  return (attributes || []).find(function (attr) {
    if (babelTypes.isJSXSpreadAttribute(attr)) {
      return false;
    }

    return attr.name.name === name;
  });
}
667723
public void attribute(final String attrName, final String attrVal) throws IOException {
    out(" ");
    out(attrName);
    out("=");
    quote(attrVal);
  }
848967
public String getAttribute(String rawName)
  {

    AVT avt = getLiteralResultAttribute(rawName);

    if ((null != avt))
    {
      return avt.getSimpleString();
    }

    return EMPTYSTRING;
  }
374134
private void extractAttributes(String attributes)
	{
		String s = attributes.trim();
		if (s.length() > 0 && s.charAt(s.length() - 1) == '/')
			elem.setEmptyElementTag(true);

		while (s.length() != 0) {
			final int equal = s.indexOf('=');
			if (equal == -1 || equal == s.length() - 1)
				break;
			// cut off attribute name
			final String att = s.substring(0, equal).trim();
			s = s.substring(equal + 1).trim();
			if (s.length() == 0)
				break;
			final boolean quote = s.charAt(0) == '\'' || s.charAt(0) == '\"';
			if (att.length() > 0 && quote) {
				String value = s.substring(1);
				final int end = value.indexOf(s.charAt(0));
				if (end >= 0)
					value = value.substring(0, end);
				elem
					.addAttribute(new Attribute(att, References.replace(value, false)));
			}
			final int i = s.indexOf(quote ? s.charAt(0) : ' ', 1);
			s = i == -1 ? "" : s.substring(i + 1);
		}
	}
895897
def GetAttribute(self, name):
        
        ret = libxml2mod.xmlTextReaderGetAttribute(self._o, name)
        return ret
628193
public String getAttributeString(String domain, String beanName, String attributeName) throws Exception {
		return getAttributeString(ObjectNameUtil.makeObjectName(domain, beanName), attributeName);
	}
786269
public static String getTagAttr(StringBuilder page, final String tag,
			final String attr) {

		String found = null;
		Pattern daPattern = TagMagix.getPattern(tag, attr);
		Matcher matcher = daPattern.matcher(page);
		int idx = 0;

		if (matcher.find(idx)) {
			found = matcher.group(1);
			found = trimAttrValue(found);
		}

		return found;
	}
1344617
function getAttribute(path, attrNode) {
    path.forEach(attrName => {
        if (!(attrNode.attributes && attrNode.attributes[attrName])) {
            throw new ImplementationError(`Result-Builder: Unknown attribute "${path.join('.')}"`);
        }
        attrNode = attrNode.attributes[attrName];
    });
    return attrNode;
}
825267
def getAttribute(self, attrName, defaultValue=None):
        '''
            
        '''

        if attrName in TAG_ITEM_BINARY_ATTRIBUTES:
            if attrName in self._attributes:
                attrVal = self._attributes[attrName]
                if not attrVal:
                    return True # Empty valued binary attribute

                return attrVal # optionally-valued binary attribute
            else:
                return False
        else:
            return self._attributes.get(attrName, defaultValue)
1034374
public static String open(Tag tag, AttributeValue... attrs) {

        StringBuffer sb = new StringBuffer();
        sb.append("<").append(tag.name());
        for (AttributeValue attr : attrs) {
            sb.append(" ").append(attr.toString());
        }
        sb.append(">");
        return sb.toString();
    }