Set the pattern to be used to format date
@param {String} format a format pattern
@method setFormat
@chainable
343605
function setFormat(format) {
            if (format === null || format === undefined) {
                throw new Error("Format is not defined " + this.clazz.$name);
            }

            if (this.format !== format) {
                this.format = format;
                this.$getSuper("setValue").call(this, this.$format(this.date));
            }

            return this;
        }
561746
public void setDataFormat(final String pattern, final CellFormatter cellFormatter) {

        String currentPattern = POIUtils.getCellFormatPattern(cell, cellFormatter);
        if(currentPattern.equalsIgnoreCase(pattern)) {
            // 既に書式が同じ場合
            return;
        }

        cloneStyle();
        cell.getCellStyle().setDataFormat(POIUtils.getDataFormatIndex(cell.getSheet(), pattern));

    }
841020
public void setFormat(CmsObject cms, String format) {

        if (CmsStringUtil.isEmptyOrWhitespaceOnly(format)) {
            m_format = "";
            if (m_element.element(PARAM_FORMAT) != null) {
                m_element.remove(m_element.element(PARAM_FORMAT));
            }
        } else {
            m_format = format;
        }
        setParameterValue(cms, PARAM_FORMAT, format);
    }
1009533
public static String format(Date date, String format) {
		if (null == date || StrUtil.isBlank(format)) {
			return null;
		}
		return format(date, FastDateFormat.getInstance(format));
	}
384644
function(format, value) {
      var date = helpers.date.parse(value);

      if(date === false || date === undefined) return false;

      var day = date.getDate().toString().replace(/(?=(^\d{1}$))/g, "0");
      var month = (date.getMonth() + 1).toString().replace(/(?=(^\d{1}$))/g, "0");

      var formatDate = format
         .replace(/dd/gi, day)
         .replace(/mm/gi, month)
         .replace(/yyyy/gi, date.getFullYear());

      return formatDate;
   }
167372
function fixFormat(format, _moment) {
    var i = 5;
    var replace = function (input) {
        return _moment.localeData().longDateFormat(input) || input;
    };
    while (i > 0 && localFormattingTokens.test(format)) {
        i -= 1;
        format = format.replace(localFormattingTokens, replace);
    }
    return format;
}
1350589
public function setFormat(string $format)
    {
        // Control rendering by requested output format
        $no_render_format = [
            'json',
            'xml',
            'css',
            'js',
            'file'
        ];

        if (in_array($format, $no_render_format)) {
            $this->render = false;
        }

        $this->format = $format;
    }
951694
public void setFormat(AnalyticsS3ExportFileFormat format) {
        if (format == null) {
            setFormat((String) null);
        } else {
            setFormat(format.toString());
        }
    }
521074
function(date, format) {
            var i, replacements,
                locale = locale_name();
            if(format && locale_uses_day_before_month()) {
                replacements = this.DAY_FIRST_FORMATS;
                for(i = 0; i < replacements.length; i++) {
                    format = format.replace(replacements[i][0], replacements[i][1]);
                }
            }
            if(format && locale in this.CUSTOM_LOCALE_FORMATS) {
                replacements = this.CUSTOM_LOCALE_FORMATS[locale];

                for(i = 0; i < replacements.length; i++) {
                    format = format.replace(replacements[i][0], replacements[i][1]);
                }
            }
            return format_date(date, format);
        }
438045
public void outFormat(String format, Object... args){
        format(System.out, format, args);
    }
1333074
public void setOutputFormat(String format) {
		try {
			runner.callMethod(engine, "setOutputFormat", format);
			outputFormat = format;
		} catch (ScriptRunnerException e) {
			throw new IllegalArgumentException("Could not set output format", e);
		}
	}
1200557
function normalizeFormat(format) {
  const clone = Object.assign({}, format);
  clone.prefix = normalizePrefixSuffix(format.prefix);
  clone.suffix = normalizePrefixSuffix(format.suffix);
  return clone;
}
939619
public static String format(final LocalDate self, String pattern) {
        return self.format(DateTimeFormatter.ofPattern(pattern));
    }
1195443
function splitFormat (format) {
  const prefix = format.split('.');
  const ext = prefix.pop();
  return { prefix, ext };
}
1123901
function buildFormat(format) {
  return format.v.map(x=> typeof x === 'string' ? x :
               '{' + x.p + ('o' in x ? '>' + x.o : '') + '}').join('') +
        (format.o ? '>>' + Object.keys(format.o).map(x => OPTIONS[x]).join('') : '');
}
249713
function addFormat(name, format) {
  if (typeof format == 'string') format = new RegExp(format);
  this._formats[name] = format;
  return this;
}
695344
function formatDate(date, format)
  {
    let parsedDate = new Date(date)
    if (!isDate(parsedDate))
      throw new TypeError("A date or timestamp must be provided to {{formatDate}}")

    if (isString(format) && format in formats.date)
      format = formats.date[format]

    return getCachedDateTimeFormat(locale, format).format(parsedDate)
  }