var stringUtil = {
  /* -------------------------------
   * chkCommaStr
   * ','を含んだらTrue
   ------------------------------ */
  chkCommaStr: function (o) {
    var ret = true;
    if (stringUtil.isEmpty(o)) {
      ret = false;
    } else {
      if (stringUtil.isEmpty(o.match(/,/))) {
        ret = false;
      }
    }
    return ret;
  },
  /* ------------------------------
   *  nvl
   ------------------------------ */
  nvl: function (o) {
    if (stringUtil.isEmpty(o) == true) {
      return "";
    }
    return o;
  },
  /* ------------------------------
   *  nvl0
   *  NULL->引数とする
   ------------------------------ */
  nvl0: function (o, t) {
    if (stringUtil.isEmpty(o) == true) {
      return t;
    }
    return o;
  },
  /* ------------------------------
   *  空かどうか
   ------------------------------ */
  isEmpty: function (o) {
    if (o == null) {
      return true;
    }
    if (o == undefined) {
      return true;
    }
    if (typeof o !== "string") {
      return false;
    }
    if (o === "") {
      return true;
    }
    return false;
  },
  /* ------------------------------
 *  空では無い
 ------------------------------ */
  isValid: function (o) {
    return !stringUtil.isEmpty(o);
  },
  /* ------------------------------
   * right padding
   *  コンポーネントに直接書き込み
  ------------------------------ */
  lpad: function (c) {
    if (!stringUtil.isEmpty($(c).val())) {
      var maxlength = $(c).attr("maxlength");
      var lpadlength = $(c).attr("lpadlength");

	    if (!lpadlength) {
	      lpadlength = 0;
	    }

	    if (lpadlength != "" && lpadlength != "0") {
	      maxlength = lpadlength;
	    }

      $(c).val(stringUtil.lpadStr($(c).val(), maxlength, "0"));
    }
  },
  /* ------------------------------
 * right padding
 *  コンポーネントに直接書き込み
------------------------------ */
  lpadStr: function (v, len, chr) {
    if (chr == undefined || chr == null) {
      chr = "0";
    }

    if (typeof (padStart) == "function") {
      return v.padStart(len, chr)
    } else {
      if (!chr || chr.length == 0) {
        return v;
      } else if (chr.length > 1) {
        chr = chr.charAt(0);
      }
      for (; v.length < len; v = chr + v);
      return v;
    }
  },
  /* ------------------------------
 * right padding
 *  コンポーネントに直接書き込み
------------------------------ */
  rpad: function (c) {
    var maxlength = $(c).attr("maxlength");
    $(c).val(stringUtil.rpadStr($(c).val(), maxlength, "0"));
  },
  /* ------------------------------
 * right padding
 *  コンポーネントに直接書き込み
------------------------------ */
  rpadStr: function (v, len, chr) {
    if (chr == undefined || chr == null) {
      chr = "0";
    }

    if (typeof (padEnd) == "function") {
      return v.padEnd(len, chr)
    } else {
      if (!chr || chr.length == 0) {
        return v;
      } else if (chr.length > 1) {
        chr = chr.charAt(0);
      }
      for (; v.length < len; v = v + chr);
      return v;
    }
  },

  /* ------------------------------
   *  全角→半角変換
   ------------------------------ */
  bytes2: function (str) {
    var r = 0;
    for (var i = 0; i < str.length; i++) {
      var c = str.charCodeAt(i);
      // Shift_JIS: 0x0 ～ 0x80, 0xa0  , 0xa1   ～ 0xdf  , 0xfd   ～ 0xff
      // Unicode  : 0x0 ～ 0x80, 0xf8f0, 0xff61 ～ 0xff9f, 0xf8f1 ～ 0xf8f3
      if ((c >= 0x0 && c < 0x81) || (c == 0xf8f0) || (c >= 0xff61 && c < 0xffa0) || (c >= 0xf8f1 && c < 0xf8f4)) {
        r += 1;
      } else {
        r += 2;
      }
    }
    return r;
  },

  /* ------------------------------
   *  バイト数を取得する
   ------------------------------ */
  bytes2: function (str) {
    var r = 0;
    for (var i = 0; i < str.length; i++) {
      var c = str.charCodeAt(i);
      // Shift_JIS: 0x0 ～ 0x80, 0xa0  , 0xa1   ～ 0xdf  , 0xfd   ～ 0xff
      // Unicode  : 0x0 ～ 0x80, 0xf8f0, 0xff61 ～ 0xff9f, 0xf8f1 ～ 0xf8f3
      if ((c >= 0x0 && c < 0x81) || (c == 0xf8f0) || (c >= 0xff61 && c < 0xffa0) || (c >= 0xf8f1 && c < 0xf8f4)) {
        r += 1;
      } else {
        r += 2;
      }
    }
    return r;
  },

  /* ------------------------------
   *  指定した桁数で切り取る
   *  最後の文字がマルチバイトで途中で切れる場合は、含まない
   ------------------------------ */
  substr: function (str, begin, end) {
    var ret = '';
    for (var i = 0, len = 0; i < str.length; i++ , len++) {
      var upper = str.charCodeAt(i);
      var lower = str.length > (i + 1) ? str.charCodeAt(i + 1) : 0;
      var s = '';
      if (stringUtil.isSurrogatePear(upper, lower)) {
        i++;
        s = String.fromCharCode(upper, lower);
      } else {
        s = String.fromCharCode(upper);
      }
      //----------
      if (
        ( (s >= 0x0 && s < 0x81) || (s == 0xf8f0) || (s >= 0xff61 && s < 0xffa0) || (s >= 0xf8f1 && s < 0xf8f4) )
          // 特殊文字(全角空白は半角(0x20)2文字と判断されてしまう為)
          && s != "　"
      ) {
        len += 0;
      } else {
        len += 1;
      }
      //------------
      if (begin <= len && len < end) {
        ret += s;
      }
    }
    return ret;
  },
  /* ------------------------------
   *  サロゲートペア対応
   ------------------------------ */
  isSurrogatePear: function (upper, lower) {
    return 0xD800 <= upper && upper <= 0xDBFF && 0xDC00 <= lower && lower <= 0xDFFF;
  },

  /* ------------------------------
   *  サロゲートペア対応
   ------------------------------ */
  toNumber: function (str) {
    if (stringUtil.isEmpty(str)) {
      return str;
    }
    var s = stringUtil.zen2han(str, true, true, true, true, true);
    var array2 = s.match(/-?[0-9]+\.?[0-9]*/g);
    if (array2 == null) {
      return "";
    }
    var ret = "";
    for (var i = 0; i < array2.length; i++) {
      ret += array2[i];
    }
    return ret;
  },

  /* ------------------------------
   *  今日の日付をyyyy/mm/ddで返す。
   ------------------------------ */
  getToday: function () {
    var date = new Date();
    var y = date.getFullYear();
    var m = ("00" + (date.getMonth() + 1)).slice(-2);
    var d = ("00" + date.getDate()).slice(-2);
    return [y, m, d].join("/");
  },

  getNowTime: function () {
    var date = new Date();
    var hh24 = ('00'+date.getHours()).slice(-2);
    var mm = ('00'+date.getMinutes()).slice(-2);
    return [hh24, mm].join(":");
  },

  trans2hankana: function (v) {
    console.log('v', v);
    let r = stringUtil.hira2kana(v);
    console.log('r', r);
    let s = stringUtil.zenkana2hankana(r);
    console.log('s', s);
    let t = stringUtil.zen2han(s);
    console.log('t', t);
    let u = t.replace(/[^\x00-\x7Eｧ-ﾝﾞﾟ･､\x3F]+/g,'');
    console.log('u', u);
    return u;
  },

  /* ------------------------------
   * スネークケースからキャメルケースに変換
   *
   * アンダースコア、ハイフン、半角スペースを変換
   * 先頭の区切り文字は削除
   * 変換前にある文字列中の大文字は変換されないので注意
   *
   * 「abc-def」→「abcDef」
   * 「abc-dEF」→「abcDEF」（変換前の大文字はそのまま）
   *
   * @param {String} str 変換したい文字列
   * @param {Boolean} upper アッパーキャメルケースにするかどうか
   ------------------------------ */
  snake2camel: function (str, upper) {
    str = str
      .replace(/^[\-_ ]/g, "")
      .replace(/[\-_ ]./g, function (match) {
        return match.charAt(1).toUpperCase();
      });
    return upper === true ?
      str.replace(/^[a-z]/g, function (match) {
        return match.toUpperCase();
      }) : str;
  },

  /* ------------------------------
   * キャメルケースからスネークケースに変換
   *
   * 先頭の連続した大文字は大文字の最後尾とそれ以外に分解される
   * 最後尾の連続した大文字はひとつのまとまりとして変換される
   *
   * ABCDEF → abcdef
   * abcDef → abc-def
   * AbcDef → abc-def
   * DEFClass → def-class（先頭の連続した大文字は分解）
   * classID → class-id（最後尾の連続した大文字はひとつのまとまりとして変換）
   *
   * @param {String} str 変換したい文字列
   * @param {String} separator 区切り文字（デフォルトはハイフン）
   ------------------------------ */
  camel2snake: function (str, separator) {
    separator = separator === undefined ? "-" : separator;
    return str
      .replace(/^[A-Z]+$/, function (match) {
        return match.toLowerCase();
      })
      .replace(/^[A-Z]+/, function (match) {
        if (match.length > 1) {
          return match.replace(/[A-Z]$/, function (m) {
            return separator + m.toLowerCase();
          }).toLowerCase();
        } else {
          return match.toLowerCase();
        }
      })
      .replace(/[A-Z]+$/g, function (match) {
        return separator + match.toLowerCase();
      })
      .replace(/[A-Z]/g, function (match) {
        return separator + match.toLowerCase();
      });
  },

  /* ------------------------------
   * ひらがなを全角カタカナに変換
   *
   * 濁音・半濁音のある場合一文字に変換するかは今後の課題
   *
   * 以下の文字は結合してカタカナに変換
   * 「う゛」→「ヴ」
   * 「わ゛」→「?」
   * 「ゐ゛」→「?」
   * 「ゑ゛」→「?」
   * 「を゛」→「?」
   * 「ゝ゛」→「ヾ」
   *
   * @param {String} str 変換したい文字列
   * @param {Boolean} opt 小文字の「?」「?」を変換するかどうか falseを指定した場合は変換なし
   ------------------------------ */
  hira2kana: function (str, opt) {
    str = str
      //.replace(/[ぁ-ヴ]/g, function (s) {
      .replace(/[\u3041-\u3096]/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) + 0x60);
      })
    //.replace(/ﾞ/g, '゛')
    //.replace(/ﾟ/g, '゜')
    //.replace(/(ウ゛)/g, 'ヴ')
    //.replace(/(ワ゛)/g, '?')
    //.replace(/(ヰ゛)/g, '?')
    //.replace(/(ヱ゛)/g, '?')
    //.replace(/(ヲ゛)/g, '?')
    //.replace(/(ゝ゛)/g, 'ヾ')
    //.replace(/ゝ/g, 'ヽ')
    //.replace(/ゞ/g, 'ヾ');
    if (opt !== false) {
      //str = str.replace(/\?/g, 'ヵ').replace(/\?/g, 'ヶ');
    }
    return str;
  },

  /* ------------------------------
   * 全角カタカナをひらがなに変換
   *
   * 濁音・半濁音のある場合一文字に変換するかは今後の課題
   *
   * 以下の文字を結合・展開
   * 「ウ゛」→「ヴ」
   * 「?」→「わ゛」
   * 「?」→「ゐ゛」
   * 「?」→「ゑ゛」
   * 「?」→「を゛」
   * 「ヽ゛」→「ゞ」
   *
   * ひらがなに無いカタカナは変換しない
   * 「?」「?」「?」「?」「?」「?」「?」「?」
   * 「?」「?」「?」「?」「?」「?」「?」「?」
   *
   * @param {String} str 変換したい文字列
   * @param {Boolean} opt 小文字の「ヵ」「ヶ」を変換するかどうか falseを指定した場合は変換なし
   ------------------------------ */
  kana2hira: function (str) {
    str = str
      .replace(/[ァ-ヴ]/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) - 0x60);
      })
      .replace(/ﾞ/g, '゛')
      .replace(/ﾟ/g, '゜')
      .replace(/(う゛)/g, 'ヴ')
      .replace(/\?/g, 'わ゛')
      .replace(/\?/g, 'ゐ゛')
      .replace(/\?/g, 'ゑ゛')
      .replace(/\?/g, 'を゛')
      .replace(/(ヽ゛)/g, 'ゞ')
      .replace(/ヽ/g, 'ゝ')
      .replace(/ヾ/g, 'ゞ');
    if (opt !== false) {
      str = str.replace(/ヵ/g, '?').replace(/ヶ/g, '?');
    }
    return str;
  },

  /* ------------------------------
   * 半角カタカナを全角カタカナに変換
   *
   * @param {String} str 変換したい文字列
   ------------------------------ */
  hankana2zenkana: function (str) {
    var kanaMap = {
      'ｶﾞ': 'ガ', 'ｷﾞ': 'ギ', 'ｸﾞ': 'グ', 'ｹﾞ': 'ゲ', 'ｺﾞ': 'ゴ',
      'ｻﾞ': 'ザ', 'ｼﾞ': 'ジ', 'ｽﾞ': 'ズ', 'ｾﾞ': 'ゼ', 'ｿﾞ': 'ゾ',
      'ﾀﾞ': 'ダ', 'ﾁﾞ': 'ヂ', 'ﾂﾞ': 'ヅ', 'ﾃﾞ': 'デ', 'ﾄﾞ': 'ド',
      'ﾊﾞ': 'バ', 'ﾋﾞ': 'ビ', 'ﾌﾞ': 'ブ', 'ﾍﾞ': 'ベ', 'ﾎﾞ': 'ボ',
      'ﾊﾟ': 'パ', 'ﾋﾟ': 'ピ', 'ﾌﾟ': 'プ', 'ﾍﾟ': 'ペ', 'ﾎﾟ': 'ポ',
      'ｳﾞ': 'ヴ', 'ﾜﾞ': '?', 'ｦﾞ': '?',
      'ｱ': 'ア', 'ｲ': 'イ', 'ｳ': 'ウ', 'ｴ': 'エ', 'ｵ': 'オ',
      'ｶ': 'カ', 'ｷ': 'キ', 'ｸ': 'ク', 'ｹ': 'ケ', 'ｺ': 'コ',
      'ｻ': 'サ', 'ｼ': 'シ', 'ｽ': 'ス', 'ｾ': 'セ', 'ｿ': 'ソ',
      'ﾀ': 'タ', 'ﾁ': 'チ', 'ﾂ': 'ツ', 'ﾃ': 'テ', 'ﾄ': 'ト',
      'ﾅ': 'ナ', 'ﾆ': 'ニ', 'ﾇ': 'ヌ', 'ﾈ': 'ネ', 'ﾉ': 'ノ',
      'ﾊ': 'ハ', 'ﾋ': 'ヒ', 'ﾌ': 'フ', 'ﾍ': 'ヘ', 'ﾎ': 'ホ',
      'ﾏ': 'マ', 'ﾐ': 'ミ', 'ﾑ': 'ム', 'ﾒ': 'メ', 'ﾓ': 'モ',
      'ﾔ': 'ヤ', 'ﾕ': 'ユ', 'ﾖ': 'ヨ',
      'ﾗ': 'ラ', 'ﾘ': 'リ', 'ﾙ': 'ル', 'ﾚ': 'レ', 'ﾛ': 'ロ',
      'ﾜ': 'ワ', 'ｦ': 'ヲ', 'ﾝ': 'ン',
      'ｧ': 'ァ', 'ｨ': 'ィ', 'ｩ': 'ゥ', 'ｪ': 'ェ', 'ｫ': 'ォ',
      'ｯ': 'ッ', 'ｬ': 'ャ', 'ｭ': 'ュ', 'ｮ': 'ョ',
      '｡': '。', '､': '、', 'ｰ': 'ー', '｢': '「', '｣': '」', '･': '・'
    };

    var reg = new RegExp('(' + Object.keys(kanaMap).join('|') + ')', 'g');
    return str
      .replace(reg, function (match) {
        return kanaMap[match];
      })
      .replace(/ﾞ/g, '゛')
      .replace(/ﾟ/g, '゜');
  },

  /* ------------------------------
   * 全角カタカナを半角カタカナに変換
   *
   * @param {String} str 変換したい文字列
   ------------------------------ */
  zenkana2hankana: function (str) {
    var kanaMap = {
      'ガ': 'ｶﾞ', 'ギ': 'ｷﾞ', 'グ': 'ｸﾞ', 'ゲ': 'ｹﾞ', 'ゴ': 'ｺﾞ',
      'ザ': 'ｻﾞ', 'ジ': 'ｼﾞ', 'ズ': 'ｽﾞ', 'ゼ': 'ｾﾞ', 'ゾ': 'ｿﾞ',
      'ダ': 'ﾀﾞ', 'ヂ': 'ﾁﾞ', 'ヅ': 'ﾂﾞ', 'デ': 'ﾃﾞ', 'ド': 'ﾄﾞ',
      'バ': 'ﾊﾞ', 'ビ': 'ﾋﾞ', 'ブ': 'ﾌﾞ', 'ベ': 'ﾍﾞ', 'ボ': 'ﾎﾞ',
      'パ': 'ﾊﾟ', 'ピ': 'ﾋﾟ', 'プ': 'ﾌﾟ', 'ペ': 'ﾍﾟ', 'ポ': 'ﾎﾟ',
      'ヴ': 'ｳﾞ',
      'ア': 'ｱ', 'イ': 'ｲ', 'ウ': 'ｳ', 'エ': 'ｴ', 'オ': 'ｵ',
      'カ': 'ｶ', 'キ': 'ｷ', 'ク': 'ｸ', 'ケ': 'ｹ', 'コ': 'ｺ',
      'サ': 'ｻ', 'シ': 'ｼ', 'ス': 'ｽ', 'セ': 'ｾ', 'ソ': 'ｿ',
      'タ': 'ﾀ', 'チ': 'ﾁ', 'ツ': 'ﾂ', 'テ': 'ﾃ', 'ト': 'ﾄ',
      'ナ': 'ﾅ', 'ニ': 'ﾆ', 'ヌ': 'ﾇ', 'ネ': 'ﾈ', 'ノ': 'ﾉ',
      'ハ': 'ﾊ', 'ヒ': 'ﾋ', 'フ': 'ﾌ', 'ヘ': 'ﾍ', 'ホ': 'ﾎ',
      'マ': 'ﾏ', 'ミ': 'ﾐ', 'ム': 'ﾑ', 'メ': 'ﾒ', 'モ': 'ﾓ',
      'ヤ': 'ﾔ', 'ユ': 'ﾕ', 'ヨ': 'ﾖ',
      'ラ': 'ﾗ', 'リ': 'ﾘ', 'ル': 'ﾙ', 'レ': 'ﾚ', 'ロ': 'ﾛ',
      'ワ': 'ﾜ', 'ヲ': 'ｦ', 'ン': 'ﾝ',
      'ァ': 'ｧ', 'ィ': 'ｨ', 'ゥ': 'ｩ', 'ェ': 'ｪ', 'ォ': 'ｫ',
      'ッ': 'ｯ', 'ャ': 'ｬ', 'ュ': 'ｭ', 'ョ': 'ｮ',
      '。': '｡', '、': '､', 'ー': 'ｰ', '「': '｢', '」': '｣',
      '・': '･', '？': '?'
    };

    var reg = new RegExp('(' + Object.keys(kanaMap).join('|') + ')', 'g');
    return str
      .replace(reg, function (match) {
        return kanaMap[match];
      })
  },

  /* ------------------------------
   * 全角から半角に置き換え
   *
   * 全角チルダ、全角波ダッシュ共に半角チルダに変換
   * 全角ハイフン、全角ダッシュ、全角マイナス記号は半角ハイフンに変換
   * 長音符は半角ハイフンに含めない（住所の地名等に使用される為）
   *
   * 今は良いがUnicode 8.0で波ダッシュの形が変わるみたいなので、波ダッシュを変換に
   * 含めるべきかどうかは検討が必要
   *
   * @param {String} str 変換したい文字列
   * @param {Boolean} tilde チルダ falseを指定した場合は変換なし
   * @param {Boolean} mark 記号 falseを指定した場合は変換なし
   * @param {Boolean} hankana 半角カナ記号 trueを指定した場合のみ変換
   * @param {Boolean} space スペース falseを指定した場合は変換なし
   * @param {Boolean} alpha 英字 falseを指定した場合は変換なし
   * @param {Boolean} num 数字 falseを指定した場合は変換なし
   ------------------------------ */
  zen2han: function (str, tilde, mark, hankana, space, alpha, num) {
    if (alpha !== false) {
      str = str.replace(/[Ａ-Ｚａ-ｚ]/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) - 65248);
      });
    }
    if (num !== false) {
      str = str.replace(/[０-９]/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) - 65248);
      });
    }
    if (mark !== false) {
      var reg = /[！＂＃＄％＆＇（）＊＋，－．／：；＜＝＞？＠［＼］＾＿｀｛｜｝]/g;
      str = str.replace(reg, function (s) {
        return String.fromCharCode(s.charCodeAt(0) - 65248);
      }).replace(/[‐－―]/g, '-');
    }
    if (tilde !== false) {
      str = str.replace(/[～]/g, '~');
    }
    if (space !== false) {
      str = str.replace(/　/g, ' ');
    }
    if (hankana === true) {
      var map = { '。': '｡', '、': '､', '「': '｢', '」': '｣', '・': '･' };
      var reg = new RegExp('(' + Object.keys(map).join('|') + ')', 'g');
      str = str.replace(reg, function (match) {
        return map[match];
      });
    }
    return str;
  },

  /* ------------------------------
   * 半角から全角に置き換え
   *
   * チルダは全角チルダに変換
   *
   * @param {String} str 変換したい文字列
   * @param {Boolean} tilde チルダ falseを指定した場合は変換なし
   * @param {Boolean} mark 記号 falseを指定した場合は変換なし
   * @param {Boolean} hankana 半角カナ記号 falseを指定した場合は変換なし
   * @param {Boolean} space スペース falseを指定した場合は変換なし
   * @param {Boolean} alpha 英字 falseを指定した場合は変換なし
   * @param {Boolean} num 数字 falseを指定した場合は変換なし
   ------------------------------ */
  han2zen: function (str, tilde, mark, hankana, space, alpha, num) {
    if (alpha !== false) {
      str = str.replace(/[A-Za-z]/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) + 65248);
      });
    }
    if (num !== false) {
      str = str.replace(/\d/g, function (s) {
        return String.fromCharCode(s.charCodeAt(0) + 65248);
      });
    }
    if (mark !== false) {
      var reg = /[!"#\$%&'\(\)\*\+,\-\.\/:;<=>\?@\[\\\]\^_`\{\|\}]/g;
      str = str.replace(reg, function (s) {
        return String.fromCharCode(s.charCodeAt(0) + 65248);
      });
    }
    if (tilde !== false) {
      str = str.replace(/~/g, '～');
    }
    if (space !== false) {
      str = str.replace(/ /g, '　');
    }
    if (hankana !== false) {
      var map = { '｡': '。', '､': '、', '｢': '「', '｣': '」', '･': '・' };
      var reg = new RegExp('(' + Object.keys(map).join('|') + ')', 'g');
      str = str.replace(reg, function (match) {
        return map[match];
      });
    }
    return str;
  },

  /* ------------------------------
   * 一文字で表記される文字を複数文字に展開する
   * 会社名等を入力する欄でこれは入れないでほしいな～と思う文字
   *
   * @param {String} str 変換する文字列
   ------------------------------ */
  one2multi: function (str) {
    var map = {
      '㈱': '(株)', '㈲': '(有)', '?': '(社)', '?': '(特)',
      '?': '(財)', '?': '(学)', '?': '(監)', '?': '株式会社'
    };
    var reg = new RegExp('(' + Object.keys(map).join('|') + ')', 'g');
    return str.replace(reg, function (match) {
      return map[match];
    });
  },

  /**
   文字列チェック
   @param  input    String  チェック対象文字列
   @param  charType String  チェック種別
                             ・"zenkaku"               : 全角文字（ひらがな・カタカナ・漢字 etc.）
                             ・"hiragana"              : 全角ひらがな
                             ・"katakana"              : 全角カタカナ
                             ・"alphanumeric"          : 半角英数字（大文字・小文字）
                             ・"numeric"               : 半角数字
                             ・"alphabetic"            : 半角英字（大文字・小文字）
                             ・"upper-alphabetic"      : 半角英字（大文字のみ）
                             ・"lower-alphabetic"      : 半角英字（小文字のみ）
                             . "zip"                   : 半角数字 + "-""
   @return Boolean チェック結果OKかどうか
                   true  : チェックOK（引数に指定した種別の文字列のみで構成されている)
                   false : チェックNG（引数に指定した種別以外の文字列が含まれている）
   */
  checkCharType: function (input, charType) {
    if (stringUtil.isEmpty(input)) {
      return true;
    }

    switch (charType) {
      // 全角文字（ひらがな・カタカナ・漢字 etc.）
      case "zenkaku":
        return (input.match(/^[^\x01-\x7E\xA1-\xDF\uFF65-\uFF9F]+$/)) ? true : false;
      // 半角(数値 ｱﾙﾌｧﾍﾞｯﾄ ｶﾅ) etc.）
      case "hankaku":
        // 数値
        return (input.match(/^[0-9a-zA-Z $!#%&()=@\_\:\;\`\{\}\.\,\/\\\^\~\|\[\]\*\"\'\-\+\<\>\?\uFF65-\uFF9F]+$/)) ? true : false;
      // 全角ひらがな
      case "hiragana":
        return (input.match(/^[\u3041-\u3096]+$/)) ? true : false;
      // 全角カタカナ
      case "katakana":
        return (input.match(/^[\u30a1-\u30f6]+$/)) ? true : false;
      // 半角英数字（大文字・小文字）
      case "alphanumeric":
        return (input.match(/^[0-9a-zA-Z]+$/)) ? true : false;
      // 半角数字
      case "numeric":
        return (input.match(/^[0-9]+$/)) ? true : false;
      // 半角英字（大文字・小文字）
      case "alphabetic":
        return (input.match(/^[a-zA-Z]+$/)) ? true : false;
      // 半角英字（大文字のみ）
      case "upper-alphabetic":
        return (input.match(/^[A-Z]+$/)) ? true : false;
      // 半角英字（小文字のみ）
      case "lower-alphabetic":
        return (input.match(/^[a-z]+$/)) ? true : false;
      // 半角数字＋"-"のみ
      case "zip":
        return (input.match(/^[0-9 \-]+$/)) ? true : false;
    }
    return false;
  },

  /* 全角半角混在チェック
   *
   */
  isKonzaiCharType: function (input) {
    if (this.checkCharType(input, "zenkaku")) {
      return false;
    }
    if (this.checkCharType(input, "hankaku")) {
      return false;
    }
    return true;
  },

  transZipCode: function (zipcoe) {
    if (stringUtil.checkCharType(zipcoe, "numeric")) {
      if (zipcoe.length == 7) {
        return zipcoe.substr(0, 3) + "-" + zipcoe.substr(3, 4);
      }
    }
    return zipcoe;
  },
  /* 文字列を逆転させる */
  reverseString: function (str) {
    return str.split("").reverse().join("");
  },

  substrb: function(text, len) {
    let str = "";
    let chars = [...text];

    console.log('len', len);

    for(let i=0; i < chars.length; i++) {
      let c = chars[i];
      let l1 = stringUtil.bytes2(str + c);
      console.log('len1', l1);
      if( stringUtil.bytes2(str + c) > len ) {
        console.log('ret1', str);
        return str
      }
      str = str + c;
    }
    console.log('ret2', str);
    return str;
  }



}
