Ringkasan fungsi sambungan rentetan dan tatasusunan yang biasa digunakan dalam pengetahuan JavaScript_Basic

Fungsi sambungan objek String:

String.prototype.trim = function() {
  return this.replace(/^\s+|\s+$/g,"");
}
String.prototype.ltrim = function() {
  return this.replace(/^\s+/g,"");
}
String.prototype.rtrim = function() {
  return this.replace(/\s+$/g,"");
}
String.prototype.splitAndTrim = function($delimiter, $limit)
{
  var $ss = this.split($delimiter, $limit);
  for(var $i=0; $i<$ss.length; $i++)
    $ss[$i] = $ss[$i].trim();

  return $ss;
}
String.prototype.htmlEntities = function () {
  return this.replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>');
}
String.prototype.stripTags = function () {
  return this.replace(/<([^>]+)>/g,'');
}
String.prototype.toArray = function() {
  return this.split('');
}
String.prototype.toIntArray = function() {
  var returnArray = [];
  for (var i=0; i<this.length; i++) {
   returnArray.push(this.charCodeAt(i));
  }
  return returnArray;
}
String.prototype.replaceAll = function($old, $snew){
  return this.replace(new RegExp($old,"gm"),$snew);
}

Penggantian pembolehubah

var a = "I Love {0}, and You Love {1},Where are {0}!";a.format("You","Me");
String.prototype.format = function(){
  var args = arguments;
  return this.replace(/\{(\d+)\}/g,function(m,i,o,n){
    return args[i];
  });
}

Tambah rentetan di hujung rentetan

String.prototype.append = function($str){
  return this.concat($str);
}

Padamkan aksara pada kedudukan indeks yang ditentukan Jika indeks tidak sah, tiada aksara akan dipadamkan

String.prototype.deleteCharAt = function($sIndex){
  if($sIndex<0 || $sIndex>=this.length){
    return this.valueOf();
  }else if($sIndex==0){
    return this.substring(1,this.length);
  }else if($sIndex==this.length-1){
    return this.substring(0,this.length-1);
  }else{
    return this.substring(0,$sIndex)+this.substring($sIndex+1);
  }
}

Padam rentetan antara indeks yang ditentukan Aksara tempat $sIndex dan $eIndex berada tidak dipadamkan. Bergantung pada deleteCharAt

String.prototype.deleteString = function($sIndex, $eIndex){
  if($sIndex==$eIndex){
    return this.deleteCharAt($sIndex);
  }else{
    if($sIndex>$eIndex){
      var tIndex=$eIndex;
      $eIndex=$sIndex;
      $sIndex=tIndex;
    }
    if($sIndex<0)$sIndex=0;
    if($eIndex>this.length-1)$eIndex=this.length-1;
    return this.substring(0,$sIndex+1)+this.substring($eIndex,this.length);
  }
}

Semak sama ada rentetan berakhir dengan rentetan tertentu (str)

String.prototype.endsWith = function($str){
  return this.substr(this.length - $str.length) == $str;
}

Periksa sama ada rentetan itu bermula dengan rentetan tertentu

String.prototype.startsWith = function(str){
  return this.substr(0, str.length) == str;
}

Membandingkan dua rentetan untuk kesaksamaan, tidak peka huruf besar-kecil

String.prototype.equalsIgnoreCase = function($str){
  if(this.length!=$str.length){
    return false;
  }else{
    var tmp1=this.toLowerCase();
    var tmp2=$str.toLowerCase();
    return tmp1==tmp2;
  }
}

Masukkan rentetan yang ditentukan selepas kedudukan yang ditentukan Jika indeks tidak sah, ia akan ditambah terus ke penghujung rentetan

String.prototype.insert = function($ofset, $str){
  if($ofset<0 || $ofset>=this.length-1){
    return this.concat($str);
  }
  return this.substring(0,$ofset)+$str+this.substring($ofset+1);
}

Tetapkan aksara pada kedudukan yang ditentukan kepada aksara atau rentetan lain yang ditentukan Jika indeks tidak sah, ia akan dikembalikan terus tanpa sebarang pemprosesan.

String.prototype.setCharAt = function($ofset, $str){
  if($ofset<0 || $ofset>=this.length-1){
    return this.valueOf();
  }
  return this.substring(0,$ofset)+$str+this.substring($ofset+1);
}
String.prototype.replaceLen = function(start, len, replaced) {
  if(!len)
    return this;

  if(start >= this.length)
    return this;

  var returnSeg = '';
  var returnSeg2 = '';
  var i = 0;
  for (; i < this.length; i++){
    var c = this.charAt(i);
    if(i < start)
      returnSeg += c;

    if(i >= start + len)
      returnSeg2 += c;
  }

  return returnSeg + replaced + returnSeg2;
}

Kelas asas lanjutan:
Gantikan aksara, ini lebih berguna apabila menggantikan aksara, seperti ***hari***jam digantikan dengan dayhour

String.prototype.replaceChar = function(target, replaced, start) {
  if(!target)
    return this;
  if(!start)
    start = 0;

  var returnVal = this.substring(0, start);
  var index = 0;
  for (var i = start; i < this.length; i++) {
    var c = this.charAt(i);
    target = typeof target == 'function' &#63; target.call(this, index) : target;
    if (c == target) {
      returnVal += typeof replaced == 'function' &#63; replaced.call(this, index) : replaced;
      while (i < this.length - 1 && this.charAt(i + 1) == c) {
        i++;
      }
      index++;
    }else{
      returnVal += c;
    }
  }

  return returnVal;
}

Susun rentetan dalam susunan terbalik

String.prototype.reverse = function(){
  var str="";
  for(var i=this.length-1;i>=0;i--){
    str=str.concat(this.charAt(i));
  }
  return str;
}

Kira panjang, setiap aksara Cina menduduki dua panjang, dan setiap aksara Inggeris menduduki satu panjang

String.prototype.ucLength = function(){
  var len = 0;
  for(var i=0;i<this.length;i++){
    if(this.charCodeAt(i)>255)len+=2;
    else len++;
  }
  return len;
}

Melapik beberapa aksara tertentu di sebelah kiri rentetan

String.prototype.lpad = function(len, s) {
  var a = new Array(this);
  var n = (len - this.length);
  for ( var i = 0; i < n; i++) {
    a.unshift(s);
  }
  return a.join("");
}

Melapik beberapa aksara tertentu di sebelah kanan rentetan

String.prototype.rpad = function(len, s) {
  var a = new Array(this);
  var n = (len - this.length);
  for ( var i = 0; i < n; i++) {
    a.push(s);
  }
  return a.join("");
}

Tukar huruf pertama rentetan kepada huruf besar

String.prototype.ucwords = function() {
  return this.substring(0,1).toUpperCase().concat(this.substring(1));
}
String.prototype.contains = function($str) {
  return this.indexOf($str) > -1 ? true : false;
}

Tukar rentetan dalam format 2008-04-02 10:08:44 kepada tarikh (nilai objek Rentetan mestilah: 2008-04-02 10:08:44)

String.prototype.toDate = function(){
  var str = this.replace(/-/g,"/");
  return (new Date(str));
}

Tukar nombor perpuluhan yang asalnya diwakili oleh rentetan kepada nombor titik terapung perpuluhan: ketepatan ialah ketepatan

String.prototype.toFloat = function(precision){
  precision = precision || 2;
  return parseFloat(this,10).toFixed(precision);
}

Tukar nombor perpuluhan yang asalnya diwakili oleh rentetan kepada integer perpuluhan

String.prototype.toInt = function(){
  return parseInt(this,10).toString();
}

Tambah dua nombor perpuluhan yang asalnya dinyatakan sebagai rentetan dan kembalikannya sebagai rentetan: addend ialah addend

String.prototype.add = function(addend){
  var sum = parseFloat(this,10) + parseFloat(addend,10);
  return sum+"";
}

Kod untuk menukar perpuluhan kepada asas lain adalah seperti berikut, nextScale ialah asas, seperti 2,8,16

String.prototype.shiftScale = function(nextScale){
  return parseFloat(this).toString(nextScale);
}

Tukar setiap pangkalan kepada yang lain:
objek ini mestilah integer
@param preScale pada asalnya ialah nombor perpuluhan
@param nextScale Untuk ditukar kepada nombor perpuluhan

String.prototype.scaleShift = function(preScale,nextScale){
  return parseInt(this,preScale).toString(nextScale);
}

Dokumen lebar penuh 2 separuh lebar.write("ABC 123, kita semua kawan baik"); String.prototype.dbc2sbc = fungsi (){
kembalikan this.replace(/[uff01-uff5e]/g,function(a){return String.fromCharCode(a.charCodeAt(0)-65248);}).replace(/u3000/g," "); > }

Fungsi sambungan tatasusunan:

var isNumeric = function(x) {
  // returns true if x is numeric and false if it is not.
  var RegExp = /^(-)?(\d*)(\.?)(\d*)$/;
  return String(x).match(RegExp);
}
var myArray = [1,'two',3,'four',5,'six',7,'eight',9,'ten'];
var oddArray=myArray.filter(isNumeric); // outputs: 1,3,5,7,9
var oddArray=myArray.some(isNumeric); // outputs: true
var oddArray=myArray.every(isNumeric); // outputs: false
var printArray =function(x, idx){
  document.writeln('['+idx+'] = '+x);
}
myArray.forEach(printArray);// outputs: [0] = 1 [1] = two [2] = 3 [3] = four [4] = 5
myArray.remove(9);
document.writeln(myArray);

if (!Array.prototype.every)
{
 Array.prototype.every = function(fun /*, thisp*/)
 {
  var len = this.length;
  if (typeof fun != "function")
   throw new TypeError();

  var thisp = arguments[1];
  for (var i = 0; i < len; i++)
  {
   if (i in this &&
     !fun.call(thisp, this[i], i, this))
    return false;
  }

  return true;
 };
}
if (!Array.prototype.filter)
{
 Array.prototype.filter = function(fun /*, thisp*/)
 {
  var len = this.length;
  if (typeof fun != "function")
   throw new TypeError();

  var res = new Array();
  var thisp = arguments[1];
  for (var i = 0; i < len; i++)
  {
   if (i in this)
   {
    var val = this[i]; // in case fun mutates this
    if (fun.call(thisp, val, i, this))
     res.push(val);
   }
  }

  return res;
 };
}
if (!Array.prototype.forEach)
{
 Array.prototype.forEach = function(fun /*, thisp*/)
 {
  var len = this.length;
  if (typeof fun != "function")
   throw new TypeError();

  var thisp = arguments[1];
  for (var i = 0; i < len; i++)
  {
   if (i in this)
    fun.call(thisp, this[i], i, this);
  }
 };
}
if (!Array.prototype.map)
{
 Array.prototype.map = function(fun /*, thisp*/)
 {
  var len = this.length;
  if (typeof fun != "function")
   throw new TypeError();

  var res = new Array(len);
  var thisp = arguments[1];
  for (var i = 0; i < len; i++)
  {
   if (i in this)
    res[i] = fun.call(thisp, this[i], i, this);
  }

  return res;
 };
}
if (!Array.prototype.some)
{
 Array.prototype.some = function(fun /*, thisp*/)
 {
  var len = this.length;
  if (typeof fun != "function")
   throw new TypeError();

  var thisp = arguments[1];
  for (var i = 0; i < len; i++)
  {
   if (i in this &&
     fun.call(thisp, this[i], i, this))
    return true;
  }

  return false;
 };
}
Array.prototype.sortNum = function() {
  return this.sort( function (a,b) { return a-b; } );
}
<!--
var tmp = [5,9,12,18,56,1,10,42,'blue',30, 7,97,53,33,30,35,27,30,'35','Ball', 'bubble'];
var thirty=tmp.find(30);       // Returns 9, 14, 17
var thirtyfive=tmp.find('35');    // Returns 18
var thirtyfive=tmp.find(35);     // Returns 15
var haveBlue=tmp.find('blue');    // Returns 8
var notFound=tmp.find('not there!'); // Returns false
var regexp1=tmp.find(/^b/);     // returns 8,20  (first letter starts with b)
var regexp1=tmp.find(/^b/i);     // returns 8,19,20 (same as above but ignore case)
-->
Array.prototype.find = function(searchStr) {
 var returnArray = false;
 for (i=0; i<this.length; i++) {
  if (typeof(searchStr) == 'function') {
   if (searchStr.test(this[i])) {
    if (!returnArray) { returnArray = [] }
    returnArray.push(i);
   }
  } else {
   if (this[i]===searchStr) {
    if (!returnArray) { returnArray = [] }
    returnArray.push(i);
   }
  }
 }
 return returnArray;
}

Tukar susunan tatasusunan secara rawak

Array.prototype.shuffle = function (){
  for(var rnd, tmp, i=this.length; i; rnd=parseInt(Math.random()*i), tmp=this[--i], this[i]=this[rnd], this[rnd]=tmp);
  return this;
}
<!--var myArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
var yourArray = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];
document.writeln(myArray.compare(yourArray)); // outputs: true;-->
Array.prototype.compare = function(testArr) {
  if (this.length != testArr.length) return false;
  for (var i = 0; i < testArr.length; i++) {
    if (this[i].compare) {
      if (!this[i].compare(testArr[i])) return false;
    }
    if (this[i] !== testArr[i]) return false;
  }
  return true;
}

Alih keluar nilai pendua dalam tatasusunan var a = new Array("5","7","7");

Array.prototype.unique = function() {
  var data = this || [];
  var a = {}; //声明一个对象，javascript的对象可以当哈希表用
  for (var i = 0; i < data.length; i++) {
    a[data[i]] = true; //设置标记，把数组的值当下标，这样就可以去掉重复的值
  }
  data.length = 0;

  for (var i in a) { //遍历对象，把已标记的还原成数组
    this[data.length] = i;
  }
  return data;
}

Array.prototype.addAll = function($array)
{
  if($array == null || $array.length == 0)
    return;

  for(var $i=0; $i<$array.length; $i++)
    this.push($array[$i]);
}

Array.prototype.contains = function($value)
{
  for(var $i=0; $i<this.length; $i++)
  {
    var $element = this[$i];
    if($element == $value)
      return true;
  }

  return false;
}

Array.prototype.indexOf = function($value)
{
  for(var $i=0; $i<this.length; $i++)
  {
    if(this[$i] == $value)
      return $i;
  }

  return -1;
}
if (!Array.prototype.lastIndexOf)
{
 Array.prototype.lastIndexOf = function(elt /*, from*/)
 {
  var len = this.length;

  var from = Number(arguments[1]);
  if (isNaN(from))
  {
   from = len - 1;
  }
  else
  {
   from = (from < 0)
      &#63; Math.ceil(from)
      : Math.floor(from);
   if (from < 0)
    from += len;
   else if (from >= len)
    from = len - 1;
  }

  for (; from > -1; from--)
  {
   if (from in this &&
     this[from] === elt)
    return from;
  }
  return -1;
 };
}
Array.prototype.insertAt = function($value, $index)
{
  if($index < 0)
    this.unshift($value);
  else if($index >= this.length)
    this.push($value);
  else
    this.splice($index, 0, $value);
}

Padamkan elemen mengikut subskrip tatasusunan

Bergantung pada indexOf

Array.prototype.removeByIndex=function($n) {
  if($n<0){　//如果n<0，则不进行任何操作。
  　　return this;
  }else{
    return this.slice(0,$n).concat(this.slice($n+1,this.length));
  }
}

Array.prototype.remove = function($value)
{
  var $index = this.indexOf($value);

  if($index != -1)
    this.splice($index, 1);
}

Array.prototype.removeAll = function()
{
  while(this.length > 0)
    this.pop();
}

Array.prototype.replace = function($oldValue, $newValue)
{
  for(var $i=0; $i<this.length; $i++)
  {
    if(this[$i] == $oldValue)
    {
      this[$i] = $newValue;
      return;
    }
  }
}

Array.prototype.swap = function($a, $b)
{
  if($a == $b)
    return;

  var $tmp = this[$a];
  this[$a] = this[$b];
  this[$b] = $tmp;
}
Array.prototype.max = function() {
  return Math.max.apply({}, this);
}
Array.prototype.min = function() {
  return Math.min.apply({}, this);
}
Array.prototype.splice = function(start, delLen, item){
  var len =this.length;
  start = start<0&#63;0:start>len&#63;len:start&#63;start:0;
  delLen=delLen<0&#63;0:delLen>len&#63;len:delLen&#63;delLen:len;

  var arr =[],res=[];
  var iarr=0,ires=0,i=0;

  for(i=0;i<len;i++){
    if(i<start|| ires>=delLen)  arr[iarr++]=this[i];
    else {
      res[ires++]=this[i];
      if(item&&ires==delLen){
        arr[iarr++]=item;
      }
    }
  }
  if(item&&ires<delLen) arr[iarr]=item;

  for(var i=0;i<arr.length;i++){
    this[i]=arr[i];
  }
  this.length=arr.length;
  return res;
}
Array.prototype.shift = function(){ if(!this) return[];return this.splice(0,1)[0];}

Tambah secara berasingan, salinan cetek kata kunci, jika anda menemui tatasusunan, salin elemen dalam tatasusunan

Array.prototype.concat = function(){
  var i=0;
  while(i<arguments.length){
    if(typeof arguments[i] === 'object'&&typeof arguments[i].splice ==='function' &&!arguments[i].propertyIsEnumerable('length')){
    // NOT SHALLOW COPY BELOW
    // Array.prototype.concat.apply(this,arguments[i++]);
      var j=0;
      while(j<arguments[i].length) this.splice(this.length,0,arguments[i][j++]);
      i++;
    } else{
      this[this.length]=arguments[i++];
    }
  }
  return this;
}

Array.prototype.join = function(separator){
  var i=0,str="";
  while(i<this.length) str+=this[i++]+separator;
  return str;
}

Array.prototype.pop = function() { return this.splice(this.length-1,1)[0];}

Array.prototype.push = function(){
  Array.prototype.splice.apply(this,
    [this.length,0].concat(Array.prototype.slice.apply(arguments))); //这里没有直接处理参数，而是复制了一下
  return this.length;
}
Array.prototype.reverse = function(){
  for(var i=0;i<this.length/2;i++){
    var temp = this[i];
    this[i]= this[this.length-1-i];
    this[this.length-1-i] = temp;
  }
  return this;
}
Array.prototype.slice = function(start, end){
  var len =this.length;
  start=start<0&#63;start+=len:start&#63;start:0;
  end =end<0&#63;end+=len:end>len&#63;len:end&#63;end:len;

  var i=start;
  var res = [];
  while(i<end){
    res.push(this[i++]);
  }
  return res;
}
//arr.unshift(ele1,ele2,ele3....)
Array.prototype.unshift =function(){
  Array.prototype.splice.apply(this,[0,0].concat(Array.prototype.slice.apply(this,arguments)));
}