Yerleşik işlevler ( vb.) Kullanılmadan .reverse()
, return ifadesine sahip bir işleve iletildiğinde JavaScript'te bir dizeyi yerinde (veya yerinde) nasıl ters çevirirsiniz .charAt()
?
Yerleşik işlevler ( vb.) Kullanılmadan .reverse()
, return ifadesine sahip bir işleve iletildiğinde JavaScript'te bir dizeyi yerinde (veya yerinde) nasıl ters çevirirsiniz .charAt()
?
Yanıtlar:
Basit ASCII karakterleriyle uğraştığınız ve yerleşik işlevleri kullanmaktan mutluluk duyduğunuz sürece, bu işe yarayacaktır:
function reverse(s){
return s.split("").reverse().join("");
}
UTF-16 veya diğer çok baytlı karakterleri destekleyen bir çözüme ihtiyacınız varsa, bu işlevin geçersiz unicode dizeleri veya komik görünen geçerli dizeler vereceğini unutmayın. Bunun yerine bu yanıtı düşünmek isteyebilirsiniz .
[... s] Unicode farkında, küçük bir düzenleme verir: -
function reverse(s){
return [...s].reverse().join("");
}
return [...s].reverse().join("");
çalışabilir.
JavaScript'te bir dizeyi tersine çevirmek için genellikle aşağıdaki teknik (veya benzeri) kullanılır:
// Don’t use this!
var naiveReverse = function(string) {
return string.split('').reverse().join('');
}
Aslında, şimdiye kadar gönderilen tüm cevaplar bu modelin bir varyasyonudur. Ancak bu çözümde bazı sorunlar var. Örneğin:
naiveReverse('foo 𝌆 bar');
// → 'rab �� oof'
// Where did the `𝌆` symbol go? Whoops!
Bunun neden olduğunu merak ediyorsanız , JavaScript'in dahili karakter kodlamasını okuyun . (TL; DR: 𝌆
astral bir semboldür ve JavaScript bunu iki ayrı kod birimi olarak gösterir.)
Ancak daha fazlası var:
// To see which symbols are being used here, check:
// http://mothereff.in/js-escapes#1ma%C3%B1ana%20man%CC%83ana
naiveReverse('mañana mañana');
// → 'anãnam anañam'
// Wait, so now the tilde is applied to the `a` instead of the `n`? WAT.
Dize ters uygulamalarını test etmek için iyi bir dize şudur :
'foo 𝌆 bar mañana mañana'
Neden? Astral sembolü ( 𝌆
) ( JavaScript'teki yedek çiftlerle temsil edilir ) ve bir birleştirme işareti içerdiğinden ( ñ
sonuncusu mañana
aslında iki simgeden oluşur: U + 006E LATIN KÜÇÜK MEKTUP N ve U + 0303 BİRLEŞİK TİLDE).
Yedek çiftlerin görünme sırası tersine çevrilemez, aksi takdirde astral sembolü artık 'ters' dizede görünmez. Bu yüzden ��
önceki örnek için çıktıda bu işaretleri gördünüz .
Birleştirilen işaretler her zaman önceki sembole uygulanır, bu nedenle hem ana simgeye (U + 006E LATIN KÜÇÜK MEKTUP N) birleştirme işareti (U + 0303 BİRLEŞİK TİLDE) olarak bir bütün olarak davranmanız gerekir. Sıralarını ters çevirmek, birleştirme işaretinin dizedeki başka bir sembolle eşleştirilmesine neden olur. Bu yüzden örnek çıktı ã
yerine ñ
.
Umarım, bu şimdiye kadar gönderilen tüm cevapların neden yanlış olduğunu açıklar .
İlk sorunuzu cevaplamak için - JavaScript'te [düzgün bir şekilde bir dizeyi nasıl tersine çevirebilirsiniz - - Unicode farkında dize tersine çevirebilen küçük bir JavaScript kitaplığı yazdım. Az önce bahsettiğim sorunlardan hiçbiri yok. Kütüphaneye Esrever denir ; kodu GitHub'da ve hemen hemen her JavaScript ortamında çalışıyor. Bir kabuk yardımcı programı / ikili ile birlikte gelir, böylece isterseniz dizelerinizden dizeleri kolayca tersine çevirebilirsiniz.
var input = 'foo 𝌆 bar mañana mañana';
esrever.reverse(input);
// → 'anañam anañam rab 𝌆 oof'
“Yerinde” kısmına gelince, diğer cevaplara bakınız.
String.prototype.reverse_string=function() {return this.split("").reverse().join("");}
veya
String.prototype.reverse_string = function() {
var s = "";
var i = this.length;
while (i>0) {
s += this.substring(i-1,i);
i--;
}
return s;
}
Ayrıntılı analiz ve bir dizgeyi tersine çevirmenin on farklı yolu ve performans detayları
http://eddmann.com/posts/ten-ways-to-reverse-a-string-in-javascript/
Bu uygulamaların performansı:
Tarayıcı başına en iyi performans gösteren uygulamalar
İşte bu uygulamalar:
Uygulama 1:
function reverse(s) {
var o = '';
for (var i = s.length - 1; i >= 0; i--)
o += s[i];
return o;
}
Uygulama 2:
function reverse(s) {
var o = [];
for (var i = s.length - 1, j = 0; i >= 0; i--, j++)
o[j] = s[i];
return o.join('');
}
Uygulama 3:
function reverse(s) {
var o = [];
for (var i = 0, len = s.length; i <= len; i++)
o.push(s.charAt(len - i));
return o.join('');
}
Uygulama 4:
function reverse(s) {
return s.split('').reverse().join('');
}
Uygulama 5:
function reverse(s) {
var i = s.length,
o = '';
while (i > 0) {
o += s.substring(i - 1, i);
i--;
}
return o;
}
Uygulama 6:
function reverse(s) {
for (var i = s.length - 1, o = ''; i >= 0; o += s[i--]) { }
return o;
}
Uygulama 7:
function reverse(s) {
return (s === '') ? '' : reverse(s.substr(1)) + s.charAt(0);
}
Uygulama 8:
function reverse(s) {
function rev(s, len, o) {
return (len === 0) ? o : rev(s, --len, (o += s[len]));
};
return rev(s, s.length, '');
}
Uygulama 9:
function reverse(s) {
s = s.split('');
var len = s.length,
halfIndex = Math.floor(len / 2) - 1,
tmp;
for (var i = 0; i <= halfIndex; i++) {
tmp = s[len - i - 1];
s[len - i - 1] = s[i];
s[i] = tmp;
}
return s.join('');
}
Uygulama 10
function reverse(s) {
if (s.length < 2)
return s;
var halfIndex = Math.ceil(s.length / 2);
return reverse(s.substr(halfIndex)) +
reverse(s.substr(0, halfIndex));
}
Bütün "yerinde bir ipi ters çevir" eski bir röportaj soru C programcıları ve onlar tarafından röportaj insanlar (intikam, belki?), Sorar. Ne yazık ki, yönetilmeyen herhangi bir dilde (JS, C #, vb.) Dizeler değişmez dizeler kullandığından artık çalışmayan "Yerinde" bölümdür, böylece yeni bir bellek ayırmadan bir dizeyi taşıma fikrini yener.
Yukarıdaki çözümler gerçekten bir dizgiyi tersine çevirirken, daha fazla bellek ayırmadan yapmazlar ve bu nedenle koşulları karşılamazlar. Dizeye ayrılan şekilde doğrudan erişiminizin olması ve yerinde tersine çevirmek için orijinal bellek konumunu değiştirebilmeniz gerekir.
Şahsen, bu tür röportaj sorularından gerçekten nefret ediyorum, ama ne yazık ki, gelecek yıllarda onları görmeye devam edeceğimizden eminim.
İlk olarak, Array.from()
bir dizeyi bir diziye dönüştürmek için kullanın , sonra Array.prototype.reverse()
diziyi tersine çevirmek ve sonra Array.prototype.join()
dizeyi geri getirmek için kullanın.
const reverse = str => Array.from(str).reverse().join('');
reverse
mantığın yeniden yazımı yoktur .
string.split('')
çalışmıyor. Daha fazla açıklama için bu cevaba bakınız .
Array.from('foo 𝌆 bar mañana mañana').reverse().join('') == 'anãnam anañam rab 𝌆 oof'
Array.from('foo 𝌆 bar mañana mañana'.normalize('NFC')).reverse().join('')
olacak"anañam anañam rab 𝌆 oof"
ECMAScript'e 6'da, daha da hızlı kullanmadan bir dize tersine çevirebilir .split('')
ile, split yöntemi yayılmış operatörü şöyle:
var str = [...'racecar'].reverse().join('');
string.split('')
çoğu insan için daha açıktır [...string]
.
.split('')
, ek düzlemlerden (UTF-16'daki vekil çiftler) karakterlerle ilgili bir soruna sahiptir, çünkü kod noktası yerine UTF-16 kod birimi ile ayrılır . Forma operatörü ve (benim tercihim) bunu yapmaz. Array.from()
Partiye 3 yıl geç kaldım ...
Maalesef işaret edildiği gibi yapamazsınız. Bkz. JavaScript dizeleri değiştirilemez mi? JavaScript'te bir "dize oluşturucu" ya ihtiyacım var mı?
Yapabileceğiniz bir sonraki en iyi şey, bir dize alan ve kullandığınız dize API'sinin herhangi bir bölümünü yeniden uygulayan ancak dizeyi ters çevirmiş gibi davranan bir "görünüm" veya "sarmalayıcı" oluşturmaktır. Örneğin:
var identity = function(x){return x};
function LazyString(s) {
this.original = s;
this.length = s.length;
this.start = 0; this.stop = this.length; this.dir = 1; // "virtual" slicing
// (dir=-1 if reversed)
this._caseTransform = identity;
}
// syntactic sugar to create new object:
function S(s) {
return new LazyString(s);
}
//We now implement a `"...".reversed` which toggles a flag which will change our math:
(function(){ // begin anonymous scope
var x = LazyString.prototype;
// Addition to the String API
x.reversed = function() {
var s = new LazyString(this.original);
s.start = this.stop - this.dir;
s.stop = this.start - this.dir;
s.dir = -1*this.dir;
s.length = this.length;
s._caseTransform = this._caseTransform;
return s;
}
//We also override string coercion for some extra versatility (not really necessary):
// OVERRIDE STRING COERCION
// - for string concatenation e.g. "abc"+reversed("abc")
x.toString = function() {
if (typeof this._realized == 'undefined') { // cached, to avoid recalculation
this._realized = this.dir==1 ?
this.original.slice(this.start,this.stop) :
this.original.slice(this.stop+1,this.start+1).split("").reverse().join("");
this._realized = this._caseTransform.call(this._realized, this._realized);
}
return this._realized;
}
//Now we reimplement the String API by doing some math:
// String API:
// Do some math to figure out which character we really want
x.charAt = function(i) {
return this.slice(i, i+1).toString();
}
x.charCodeAt = function(i) {
return this.slice(i, i+1).toString().charCodeAt(0);
}
// Slicing functions:
x.slice = function(start,stop) {
// lazy chaining version of https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice
if (stop===undefined)
stop = this.length;
var relativeStart = start<0 ? this.length+start : start;
var relativeStop = stop<0 ? this.length+stop : stop;
if (relativeStart >= this.length)
relativeStart = this.length;
if (relativeStart < 0)
relativeStart = 0;
if (relativeStop > this.length)
relativeStop = this.length;
if (relativeStop < 0)
relativeStop = 0;
if (relativeStop < relativeStart)
relativeStop = relativeStart;
var s = new LazyString(this.original);
s.length = relativeStop - relativeStart;
s.start = this.start + this.dir*relativeStart;
s.stop = s.start + this.dir*s.length;
s.dir = this.dir;
//console.log([this.start,this.stop,this.dir,this.length], [s.start,s.stop,s.dir,s.length])
s._caseTransform = this._caseTransform;
return s;
}
x.substring = function() {
// ...
}
x.substr = function() {
// ...
}
//Miscellaneous functions:
// Iterative search
x.indexOf = function(value) {
for(var i=0; i<this.length; i++)
if (value==this.charAt(i))
return i;
return -1;
}
x.lastIndexOf = function() {
for(var i=this.length-1; i>=0; i--)
if (value==this.charAt(i))
return i;
return -1;
}
// The following functions are too complicated to reimplement easily.
// Instead just realize the slice and do it the usual non-in-place way.
x.match = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.replace = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.search = function() {
var s = this.toString();
return s.apply(s, arguments);
}
x.split = function() {
var s = this.toString();
return s.apply(s, arguments);
}
// Case transforms:
x.toLowerCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toLowerCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
x.toUpperCase = function() {
var s = new LazyString(this.original);
s._caseTransform = ''.toUpperCase;
s.start=this.start; s.stop=this.stop; s.dir=this.dir; s.length=this.length;
return s;
}
})() // end anonymous scope
Demo:
> r = S('abcABC')
LazyString
original: "abcABC"
__proto__: LazyString
> r.charAt(1); // doesn't reverse string!!! (good if very long)
"B"
> r.toLowerCase() // must reverse string, so does so
"cbacba"
> r.toUpperCase() // string already reversed: no extra work
"CBACBA"
> r + '-demo-' + r // natural coercion, string already reversed: no extra work
"CBAcba-demo-CBAcba"
Kicker - aşağıdakiler yerine saf matematik tarafından yapılır, her karakteri sadece bir kez ve sadece gerekirse ziyaret eder:
> 'demo: ' + S('0123456789abcdef').slice(3).reversed().slice(1,-1).toUpperCase()
"demo: EDCBA987654"
> S('0123456789ABCDEF').slice(3).reversed().slice(1,-1).toLowerCase().charAt(3)
"b"
Bu, çok küçük bir dizeye uygulanırsa, sadece nispeten küçük bir dilim alıyorsanız, önemli tasarruflar sağlar.
Buna değip değmeyeceği (çoğu programlama dilinde olduğu gibi kopya olarak tersine çevirme) büyük ölçüde kullanım durumunuza ve dize API'sını ne kadar verimli bir şekilde yeniden uyguladığınıza bağlıdır. Örneğin, istediğiniz tek şey dizgi dizini manipülasyonu yapmak veya küçük slice
s veya substr
s almaksa, bu size yer ve zaman kazandırır. Bununla birlikte, büyük ters çevrilmiş dilimleri veya alt dizeleri yazdırmayı planlıyorsanız, tasarruflar küçük olabilir, tam bir kopya yapmaktan bile daha kötü olabilir. "Tersine çevrilmiş" dizeniz de türüne sahip olmayacaktır string
, ancak bunu prototipleme ile taklit edebilirsiniz.
Yukarıdaki demo uygulaması ReversedString türünde yeni bir nesne oluşturur. Neredeyse minimum çalışma ve minimum alan yükü ile prototip ve bu nedenle oldukça verimlidir (prototip tanımları paylaşılır). Ertelenmiş dilimlemeyi içeren tembel bir uygulamadır. .slice
Veya gibi bir işlevi .reversed
gerçekleştirdiğinizde, dizin matematiği gerçekleştirir. Son olarak, veriyi (dolaylı olarak çağırarak .toString()
veya bir .charCodeAt(...)
şeyle) ayıkladığınızda , bu verileri mümkün olan en az veriye dokunarak "akıllı" bir şekilde uygular.
Not: Yukarıdaki dize API'si bir örnektir ve mükemmel bir şekilde uygulanamayabilir. İhtiyacınız olan sadece 1-2 işlevi de kullanabilirsiniz.
JavaScript'te bir dizeyi tersine çevirmenin birçok yolu vardır. Tercih ettiğim üç yolu not alıyorum.
Yaklaşım 1: Ters fonksiyonu kullanma:
function reverse(str) {
return str.split('').reverse().join('');
}
Yaklaşım 2: Karakterler arasında geçiş yapma:
function reverse(str) {
let reversed = '';
for (let character of str) {
reversed = character + reversed;
}
return reversed;
}
Yaklaşım 3: Azaltma fonksiyonunu kullanma:
function reverse(str) {
return str.split('').reduce((rev, char) => char + rev, '');
}
Umarım bu yardımcı olur :)
Bir röportaj sırasında, herhangi bir değişken veya yerel yöntem kullanmadan bir dizeyi ters çevirmem istendi. Bu benim en sevdiğim uygulama:
function reverseString(str) {
return str === '' ? '' : reverseString(str.slice(1)) + str[0];
}
slice
? : - /
Array.prototype.reverse()
.
Bunu yapmanın birden fazla yolu vardır, aşağıdakileri kontrol edebilirsiniz,
1. döngü için Geleneksel (artan):
function reverseString(str){
let stringRev ="";
for(let i= 0; i<str.length; i++){
stringRev = str[i]+stringRev;
}
return stringRev;
}
alert(reverseString("Hello World!"));
2. döngü için Geleneksel (azalan):
function reverseString(str){
let revstr = "";
for(let i = str.length-1; i>=0; i--){
revstr = revstr+ str[i];
}
return revstr;
}
alert(reverseString("Hello World!"));
3. for-loop kullanarak
function reverseString(str){
let strn ="";
for(let char of str){
strn = char + strn;
}
return strn;
}
alert(reverseString("Get well soon"));
4. forEach / yüksek sıralı dizi yöntemini kullanarak:
function reverseString(str){
let revSrring = "";
str.split("").forEach(function(char){
revSrring = char + revSrring;
});
return revSrring;
}
alert(reverseString("Learning JavaScript"));
5. ES6 standardı:
function reverseString(str){
let revSrring = "";
str.split("").forEach(char => revSrring = char + revSrring);
return revSrring;
}
alert(reverseString("Learning JavaScript"));
6. son yolu:
function reverseString(str){
return str.split("").reduce(function(revString, char){
return char + revString;
}, "");
}
alert(reverseString("Learning JavaScript"));
7. Aşağıdakileri kullanarak da sonuç alabilirsiniz,
function reverseString(str){
return str.split("").reduce((revString, char)=> char + revString, "");
}
alert(reverseString("Learning JavaScript"));
ES6'da bir seçeneğiniz daha var
function reverseString (str) {
return [...str].reverse().join('')
}
reverseString('Hello');
Bence bu en kolay yol
var reverse = function(str) {
var arr = [];
for (var i = 0, len = str.length; i <= len; i++) {
arr.push(str.charAt(len - i))
}
return arr.join('');
}
console.log(reverse('I want a 🍺'));
Array.prototype.reverse()
bundan en kolay ve dolayısıyla en popüler cevap olacaktır. Tabii ki, iyi bir JavaScript bilgisi gerektirir.
Bunun iyi yanıtlanmış eski bir soru olduğunu biliyorum, ancak kendi eğlencem için aşağıdaki ters işlevi yazdım ve başka biri için yararlı olması durumunda paylaşacağımı düşündüm. Hem vekil çiftleri hem de işaretleri birleştirir:
function StringReverse (str)
{
var charArray = [];
for (var i = 0; i < str.length; i++)
{
if (i+1 < str.length)
{
var value = str.charCodeAt(i);
var nextValue = str.charCodeAt(i+1);
if ( ( value >= 0xD800 && value <= 0xDBFF
&& (nextValue & 0xFC00) == 0xDC00) // Surrogate pair)
|| (nextValue >= 0x0300 && nextValue <= 0x036F)) // Combining marks
{
charArray.unshift(str.substring(i, i+2));
i++; // Skip the other half
continue;
}
}
// Otherwise we just have a rogue surrogate marker or a plain old character.
charArray.unshift(str[i]);
}
return charArray.join('');
}
JavaScript, karakter kodlamanın karmaşıklığı konusunda beni eğitmek için Mathias, Punycode ve diğer çeşitli referanslara yapılan tüm destekler.
Yapamazsınız çünkü JS dizeleri değişmezdir. Kısa yerinde olmayan çözüm
[...str].reverse().join``
Herhangi bir yerleşik işlev kullanmak istemiyorsanız. Bunu dene
var string = 'abcdefg';
var newstring = '';
for(let i = 0; i < string.length; i++){
newstring = string[i] += newstring;
}
console.log(newstring);
Gerçek cevap şudur: onu tersine çeviremezsiniz, ancak tersi olan yeni bir dize oluşturabilirsiniz.
Tıpkı özyineleme ile oynamak için bir alıştırma olarak: bazen röportaja gittiğinizde, görüşmeci size özyineleme kullanarak bunu nasıl yapacağınızı sorabilir ve bence "tercih edilen cevap" olabilir "Bunu özyineleme olarak yapmamayı tercih ederim bir yığın taşmasına neden olabilir "(çünkü O(n)
daha doğrudur O(log n)
. Öyle ise O(log n)
, yığın taşması elde etmek oldukça zordur - 4 milyar öğe 32 yığın düzeyinde işlenebilir, çünkü 2 ** 32 4294967296. Ancak öyleyse O(n)
, bir yığın taşmasını kolayca alabilir.
Bazen görüşmeci hala size "tıpkı bir alıştırma olarak, neden hala özyineleme kullanarak yazmıyorsunuz?" Diye soracaktır. Ve işte burada:
String.prototype.reverse = function() {
if (this.length <= 1) return this;
else return this.slice(1).reverse() + this.slice(0,1);
}
test sürüşü:
var s = "";
for(var i = 0; i < 1000; i++) {
s += ("apple" + i);
}
console.log(s.reverse());
çıktı:
999elppa899elppa...2elppa1elppa0elppa
Bir yığın taşması alıyorum denemek için, ben değiştim 1000
için 10000
Google Chrome'da ve rapor:
RangeError: Maximum call stack size exceeded
//es6
//array.from
const reverseString = (string) => Array.from(string).reduce((a, e) => e + a);
//split
const reverseString = (string) => string.split('').reduce((a, e) => e + a);
//split problem
"𠜎𠺢".split('')[0] === Array.from("𠜎𠺢")[0] // "�" === "𠜎" => false
"😂😹🤗".split('')[0] === Array.from("😂😹🤗")[0] // "�" === "😂" => false
Hem aksanları hem de 2 baytlık karakterleri birleştiren küçük bir işlev:
(function(){
var isCombiningDiacritic = function( code )
{
return (0x0300 <= code && code <= 0x036F) // Comb. Diacritical Marks
|| (0x1AB0 <= code && code <= 0x1AFF) // Comb. Diacritical Marks Extended
|| (0x1DC0 <= code && code <= 0x1DFF) // Comb. Diacritical Marks Supplement
|| (0x20D0 <= code && code <= 0x20FF) // Comb. Diacritical Marks for Symbols
|| (0xFE20 <= code && code <= 0xFE2F); // Comb. Half Marks
};
String.prototype.reverse = function()
{
var output = "",
i = this.length - 1,
width;
for ( ; i >= 0; --i )
{
width = 1;
while( i > 0 && isCombiningDiacritic( this.charCodeAt(i) ) )
{
--i;
width++;
}
if (
i > 0
&& "\uDC00" <= this[i] && this[i] <= "\uDFFF"
&& "\uD800" <= this[i-1] && this[i-1] <= "\uDBFF"
)
{
--i;
width++;
}
output += this.substr( i, width );
}
return output;
}
})();
// Tests
[
'abcdefg',
'ab\u0303c',
'a\uD83C\uDFA5b',
'a\uD83C\uDFA5b\uD83C\uDFA6c',
'a\uD83C\uDFA5b\u0306c\uD83C\uDFA6d',
'TO͇̹̺ͅƝ̴ȳ̳ TH̘Ë͖́̉ ͠P̯͍̭O̚N̐Y̡' // copied from http://stackoverflow.com/a/1732454/1509264
].forEach(
function(str){ console.log( str + " -> " + str.reverse() ); }
);
Güncelleme
Aksanları birleştirmenin daha eksiksiz bir listesi:
var isCombiningDiacritic = function( code )
{
return (0x0300 <= code && code <= 0x036F)
|| (0x0483 <= code && code <= 0x0489)
|| (0x0591 <= code && code <= 0x05BD)
|| (code == 0x05BF)
|| (0x05C1 <= code && code <= 0x05C2)
|| (0x05C4 <= code && code <= 0x05C5)
|| (code == 0x05C7)
|| (0x0610 <= code && code <= 0x061A)
|| (0x064B <= code && code <= 0x065F)
|| (code == 0x0670)
|| (0x06D6 <= code && code <= 0x06DC)
|| (0x06DF <= code && code <= 0x06E4)
|| (0x06E7 <= code && code <= 0x06E8)
|| (0x06EA <= code && code <= 0x06ED)
|| (code == 0x0711)
|| (0x0730 <= code && code <= 0x074A)
|| (0x07A6 <= code && code <= 0x07B0)
|| (0x07EB <= code && code <= 0x07F3)
|| (code == 0x07FD)
|| (0x0816 <= code && code <= 0x0819)
|| (0x081B <= code && code <= 0x0823)
|| (0x0825 <= code && code <= 0x0827)
|| (0x0829 <= code && code <= 0x082D)
|| (0x0859 <= code && code <= 0x085B)
|| (0x08D3 <= code && code <= 0x08E1)
|| (0x08E3 <= code && code <= 0x0902)
|| (code == 0x093A)
|| (code == 0x093C)
|| (0x0941 <= code && code <= 0x0948)
|| (code == 0x094D)
|| (0x0951 <= code && code <= 0x0957)
|| (0x0962 <= code && code <= 0x0963)
|| (code == 0x0981)
|| (code == 0x09BC)
|| (0x09C1 <= code && code <= 0x09C4)
|| (code == 0x09CD)
|| (0x09E2 <= code && code <= 0x09E3)
|| (0x09FE <= code && code <= 0x0A02)
|| (code == 0x0A3C)
|| (0x0A41 <= code && code <= 0x0A51)
|| (0x0A70 <= code && code <= 0x0A71)
|| (code == 0x0A75)
|| (0x0A81 <= code && code <= 0x0A82)
|| (code == 0x0ABC)
|| (0x0AC1 <= code && code <= 0x0AC8)
|| (code == 0x0ACD)
|| (0x0AE2 <= code && code <= 0x0AE3)
|| (0x0AFA <= code && code <= 0x0B01)
|| (code == 0x0B3C)
|| (code == 0x0B3F)
|| (0x0B41 <= code && code <= 0x0B44)
|| (0x0B4D <= code && code <= 0x0B56)
|| (0x0B62 <= code && code <= 0x0B63)
|| (code == 0x0B82)
|| (code == 0x0BC0)
|| (code == 0x0BCD)
|| (code == 0x0C00)
|| (code == 0x0C04)
|| (0x0C3E <= code && code <= 0x0C40)
|| (0x0C46 <= code && code <= 0x0C56)
|| (0x0C62 <= code && code <= 0x0C63)
|| (code == 0x0C81)
|| (code == 0x0CBC)
|| (0x0CCC <= code && code <= 0x0CCD)
|| (0x0CE2 <= code && code <= 0x0CE3)
|| (0x0D00 <= code && code <= 0x0D01)
|| (0x0D3B <= code && code <= 0x0D3C)
|| (0x0D41 <= code && code <= 0x0D44)
|| (code == 0x0D4D)
|| (0x0D62 <= code && code <= 0x0D63)
|| (code == 0x0DCA)
|| (0x0DD2 <= code && code <= 0x0DD6)
|| (code == 0x0E31)
|| (0x0E34 <= code && code <= 0x0E3A)
|| (0x0E47 <= code && code <= 0x0E4E)
|| (code == 0x0EB1)
|| (0x0EB4 <= code && code <= 0x0EBC)
|| (0x0EC8 <= code && code <= 0x0ECD)
|| (0x0F18 <= code && code <= 0x0F19)
|| (code == 0x0F35)
|| (code == 0x0F37)
|| (code == 0x0F39)
|| (0x0F71 <= code && code <= 0x0F7E)
|| (0x0F80 <= code && code <= 0x0F84)
|| (0x0F86 <= code && code <= 0x0F87)
|| (0x0F8D <= code && code <= 0x0FBC)
|| (code == 0x0FC6)
|| (0x102D <= code && code <= 0x1030)
|| (0x1032 <= code && code <= 0x1037)
|| (0x1039 <= code && code <= 0x103A)
|| (0x103D <= code && code <= 0x103E)
|| (0x1058 <= code && code <= 0x1059)
|| (0x105E <= code && code <= 0x1060)
|| (0x1071 <= code && code <= 0x1074)
|| (code == 0x1082)
|| (0x1085 <= code && code <= 0x1086)
|| (code == 0x108D)
|| (code == 0x109D)
|| (0x135D <= code && code <= 0x135F)
|| (0x1712 <= code && code <= 0x1714)
|| (0x1732 <= code && code <= 0x1734)
|| (0x1752 <= code && code <= 0x1753)
|| (0x1772 <= code && code <= 0x1773)
|| (0x17B4 <= code && code <= 0x17B5)
|| (0x17B7 <= code && code <= 0x17BD)
|| (code == 0x17C6)
|| (0x17C9 <= code && code <= 0x17D3)
|| (code == 0x17DD)
|| (0x180B <= code && code <= 0x180D)
|| (0x1885 <= code && code <= 0x1886)
|| (code == 0x18A9)
|| (0x1920 <= code && code <= 0x1922)
|| (0x1927 <= code && code <= 0x1928)
|| (code == 0x1932)
|| (0x1939 <= code && code <= 0x193B)
|| (0x1A17 <= code && code <= 0x1A18)
|| (code == 0x1A1B)
|| (code == 0x1A56)
|| (0x1A58 <= code && code <= 0x1A60)
|| (code == 0x1A62)
|| (0x1A65 <= code && code <= 0x1A6C)
|| (0x1A73 <= code && code <= 0x1A7F)
|| (0x1AB0 <= code && code <= 0x1B03)
|| (code == 0x1B34)
|| (0x1B36 <= code && code <= 0x1B3A)
|| (code == 0x1B3C)
|| (code == 0x1B42)
|| (0x1B6B <= code && code <= 0x1B73)
|| (0x1B80 <= code && code <= 0x1B81)
|| (0x1BA2 <= code && code <= 0x1BA5)
|| (0x1BA8 <= code && code <= 0x1BA9)
|| (0x1BAB <= code && code <= 0x1BAD)
|| (code == 0x1BE6)
|| (0x1BE8 <= code && code <= 0x1BE9)
|| (code == 0x1BED)
|| (0x1BEF <= code && code <= 0x1BF1)
|| (0x1C2C <= code && code <= 0x1C33)
|| (0x1C36 <= code && code <= 0x1C37)
|| (0x1CD0 <= code && code <= 0x1CD2)
|| (0x1CD4 <= code && code <= 0x1CE0)
|| (0x1CE2 <= code && code <= 0x1CE8)
|| (code == 0x1CED)
|| (code == 0x1CF4)
|| (0x1CF8 <= code && code <= 0x1CF9)
|| (0x1DC0 <= code && code <= 0x1DFF)
|| (0x20D0 <= code && code <= 0x20F0)
|| (0x2CEF <= code && code <= 0x2CF1)
|| (code == 0x2D7F)
|| (0x2DE0 <= code && code <= 0x2DFF)
|| (0x302A <= code && code <= 0x302D)
|| (0x3099 <= code && code <= 0x309A)
|| (0xA66F <= code && code <= 0xA672)
|| (0xA674 <= code && code <= 0xA67D)
|| (0xA69E <= code && code <= 0xA69F)
|| (0xA6F0 <= code && code <= 0xA6F1)
|| (code == 0xA802)
|| (code == 0xA806)
|| (code == 0xA80B)
|| (0xA825 <= code && code <= 0xA826)
|| (0xA8C4 <= code && code <= 0xA8C5)
|| (0xA8E0 <= code && code <= 0xA8F1)
|| (code == 0xA8FF)
|| (0xA926 <= code && code <= 0xA92D)
|| (0xA947 <= code && code <= 0xA951)
|| (0xA980 <= code && code <= 0xA982)
|| (code == 0xA9B3)
|| (0xA9B6 <= code && code <= 0xA9B9)
|| (0xA9BC <= code && code <= 0xA9BD)
|| (code == 0xA9E5)
|| (0xAA29 <= code && code <= 0xAA2E)
|| (0xAA31 <= code && code <= 0xAA32)
|| (0xAA35 <= code && code <= 0xAA36)
|| (code == 0xAA43)
|| (code == 0xAA4C)
|| (code == 0xAA7C)
|| (code == 0xAAB0)
|| (0xAAB2 <= code && code <= 0xAAB4)
|| (0xAAB7 <= code && code <= 0xAAB8)
|| (0xAABE <= code && code <= 0xAABF)
|| (code == 0xAAC1)
|| (0xAAEC <= code && code <= 0xAAED)
|| (code == 0xAAF6)
|| (code == 0xABE5)
|| (code == 0xABE8)
|| (code == 0xABED)
|| (code == 0xFB1E)
|| (0xFE00 <= code && code <= 0xFE0F)
|| (0xFE20 <= code && code <= 0xFE2F)
|| (code == 0x101FD)
|| (code == 0x102E0)
|| (0x10376 <= code && code <= 0x1037A)
|| (0x10A01 <= code && code <= 0x10A0F)
|| (0x10A38 <= code && code <= 0x10A3F)
|| (0x10AE5 <= code && code <= 0x10AE6)
|| (0x10D24 <= code && code <= 0x10D27)
|| (0x10F46 <= code && code <= 0x10F50)
|| (code == 0x11001)
|| (0x11038 <= code && code <= 0x11046)
|| (0x1107F <= code && code <= 0x11081)
|| (0x110B3 <= code && code <= 0x110B6)
|| (0x110B9 <= code && code <= 0x110BA)
|| (0x11100 <= code && code <= 0x11102)
|| (0x11127 <= code && code <= 0x1112B)
|| (0x1112D <= code && code <= 0x11134)
|| (code == 0x11173)
|| (0x11180 <= code && code <= 0x11181)
|| (0x111B6 <= code && code <= 0x111BE)
|| (0x111C9 <= code && code <= 0x111CC)
|| (0x1122F <= code && code <= 0x11231)
|| (code == 0x11234)
|| (0x11236 <= code && code <= 0x11237)
|| (code == 0x1123E)
|| (code == 0x112DF)
|| (0x112E3 <= code && code <= 0x112EA)
|| (0x11300 <= code && code <= 0x11301)
|| (0x1133B <= code && code <= 0x1133C)
|| (code == 0x11340)
|| (0x11366 <= code && code <= 0x11374)
|| (0x11438 <= code && code <= 0x1143F)
|| (0x11442 <= code && code <= 0x11444)
|| (code == 0x11446)
|| (code == 0x1145E)
|| (0x114B3 <= code && code <= 0x114B8)
|| (code == 0x114BA)
|| (0x114BF <= code && code <= 0x114C0)
|| (0x114C2 <= code && code <= 0x114C3)
|| (0x115B2 <= code && code <= 0x115B5)
|| (0x115BC <= code && code <= 0x115BD)
|| (0x115BF <= code && code <= 0x115C0)
|| (0x115DC <= code && code <= 0x115DD)
|| (0x11633 <= code && code <= 0x1163A)
|| (code == 0x1163D)
|| (0x1163F <= code && code <= 0x11640)
|| (code == 0x116AB)
|| (code == 0x116AD)
|| (0x116B0 <= code && code <= 0x116B5)
|| (code == 0x116B7)
|| (0x1171D <= code && code <= 0x1171F)
|| (0x11722 <= code && code <= 0x11725)
|| (0x11727 <= code && code <= 0x1172B)
|| (0x1182F <= code && code <= 0x11837)
|| (0x11839 <= code && code <= 0x1183A)
|| (0x119D4 <= code && code <= 0x119DB)
|| (code == 0x119E0)
|| (0x11A01 <= code && code <= 0x11A06)
|| (0x11A09 <= code && code <= 0x11A0A)
|| (0x11A33 <= code && code <= 0x11A38)
|| (0x11A3B <= code && code <= 0x11A3E)
|| (code == 0x11A47)
|| (0x11A51 <= code && code <= 0x11A56)
|| (0x11A59 <= code && code <= 0x11A5B)
|| (0x11A8A <= code && code <= 0x11A96)
|| (0x11A98 <= code && code <= 0x11A99)
|| (0x11C30 <= code && code <= 0x11C3D)
|| (0x11C92 <= code && code <= 0x11CA7)
|| (0x11CAA <= code && code <= 0x11CB0)
|| (0x11CB2 <= code && code <= 0x11CB3)
|| (0x11CB5 <= code && code <= 0x11CB6)
|| (0x11D31 <= code && code <= 0x11D45)
|| (code == 0x11D47)
|| (0x11D90 <= code && code <= 0x11D91)
|| (code == 0x11D95)
|| (code == 0x11D97)
|| (0x11EF3 <= code && code <= 0x11EF4)
|| (0x16AF0 <= code && code <= 0x16AF4)
|| (0x16B30 <= code && code <= 0x16B36)
|| (code == 0x16F4F)
|| (0x16F8F <= code && code <= 0x16F92)
|| (0x1BC9D <= code && code <= 0x1BC9E)
|| (0x1D167 <= code && code <= 0x1D169)
|| (0x1D17B <= code && code <= 0x1D182)
|| (0x1D185 <= code && code <= 0x1D18B)
|| (0x1D1AA <= code && code <= 0x1D1AD)
|| (0x1D242 <= code && code <= 0x1D244)
|| (0x1DA00 <= code && code <= 0x1DA36)
|| (0x1DA3B <= code && code <= 0x1DA6C)
|| (code == 0x1DA75)
|| (code == 0x1DA84)
|| (0x1DA9B <= code && code <= 0x1E02A)
|| (0x1E130 <= code && code <= 0x1E136)
|| (0x1E2EC <= code && code <= 0x1E2EF)
|| (0x1E8D0 <= code && code <= 0x1E8D6)
|| (0x1E944 <= code && code <= 0x1E94A)
|| (0xE0100 <= code && code <= 0xE01EF);
};
isCombiningDiacritic
, tüm 316 aralığını içerecek şekilde işlevi düzenlemektir ; elinizde veri olduğu için bu düzenlemeyi yapmaktan çekinmeyin.
function reverseString(string) {
var reversedString = "";
var stringLength = string.length - 1;
for (var i = stringLength; i >= 0; i--) {
reversedString += string[i];
}
return reversedString;
}
dizgiyi diziye dönüştürmeden;
String.prototype.reverse = function() {
var ret = "";
var size = 0;
for (var i = this.length - 1; -1 < i; i -= size) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
size = 2;
ret += this[i - 1] + this[i];
} else {
size = 1;
ret += this[i];
}
}
return ret;
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
karakterleri kod noktalarına dönüştürmeden Array.reverse kullanmak;
String.prototype.reverse = function() {
var array = this.split("").reverse();
for (var i = 0; i < this.length; ++i) {
if (
'\uD800' <= this[i - 1] && this[i - 1] <= '\uDBFF' &&
'\uDC00' <= this[i] && this[i] <= '\uDFFF'
) {
array[i - 1] = array[i - 1] + array[i];
array[i] = array[i - 1].substr(0, 1);
array[i - 1] = array[i - 1].substr(1, 1);
}
}
return array.join("");
}
console.log('anãnam anañam' === 'mañana mañana'.reverse());
var c = array[i-1]; array[i-1] = array[i]; array[i] = c;
kod çiftinin birleştirilmesini gerektirmez. Ayrıca, for döngüsü 1'den başlamalıdır.
'\ud83c\ud83c\udfa5'.reverse()
- girişle aynı çıktıyı verir. İfadenin ++i;
içine eklemek if
bunu düzeltmelidir.
'a\u0303bc'.reverse() === 'cba\u0303'
doğru dönmelidir.
Ben String.prototype.reverse bu sorunu çözmek için iyi bir yol olduğunu düşünüyorum; kodu aşağıdaki gibi;
String.prototype.reverse = function() {
return this.split('').reverse().join('');
}
var str = 'this is a good example for string reverse';
str.reverse();
-> "esrever gnirts rof elpmaxe doog a si siht";
var str = "my name is saurabh ";
var empStr='',finalString='';
var chunk=[];
function reverse(str){
var i,j=0,n=str.length;
for(i=0;i<n;++i){
if(str[i]===' '){
chunk[j]=empStr;
empStr = '';
j++;
}else{
empStr=empStr+str[i];
}
}
for(var z=chunk.length-1;z>=0;z--){
finalString = finalString +' '+ chunk[z];
console.log(finalString);
}
return true;
}
reverse(str);
Kendi orijinal girişimim ...
var str = "The Car";
function reverseStr(str) {
var reversed = "";
var len = str.length;
for (var i = 1; i < (len + 1); i++) {
reversed += str[len - i];
}
return reversed;
}
var strReverse = reverseStr(str);
console.log(strReverse);
// "raC ehT"
KURU ve basit saçma tutmak !!
function reverse(s){
let str = s;
var reverse = '';
for (var i=str.length;i>0;i--){
var newstr = str.substring(0,i)
reverse += newstr.substr(-1,1)
}
return reverse;
}
Tamam, oldukça basit, kullanmadan dizeyi tersine çevirmek için basit bir döngü ile bir işlev oluşturabilirsiniz reverse()
,charAt()
:
Örneğin şu dizeye sahipsiniz:
var name = "StackOverflow";
Böyle bir fonksiyon yarat, ben diyorum reverseString
...
function reverseString(str) {
if(!str.trim() || 'string' !== typeof str) {
return;
}
let l=str.length, s='';
while(l > 0) {
l--;
s+= str[l];
}
return s;
}
Ve şöyle diyebilirsiniz:
reverseString(name);
Ve sonuç şöyle olacak:
"wolfrevOkcatS"
JavaScript'te bir dizeyi tersine çevirmenin en iyi yolları
1) Dizi. Ters:
Muhtemelen düşünüyorsun, bekle bir ipi tersine çevirdiğimizi sanıyordum, neden Array.reverse yöntemini kullanıyorsun. String.split yöntemini kullanarak dizemizi bir karakter dizisine dönüştürüyoruz. Sonra dizideki her bir değerin sırasını tersine çeviriyoruz ve son olarak Array.join yöntemini kullanarak Diziyi geri bir String'e dönüştürüyoruz.
function reverseString(str) {
return str.split('').reverse().join('');
}
reverseString('dwayne');
2) Döngü sırasında azalma:
Oldukça ayrıntılı olmasına rağmen, bu çözüm, birinci çözümden daha avantajlıdır. Bir dizi oluşturmuyorsunuz ve sadece bir dizeyi kaynak dizgideki karakterlere göre birleştiriyorsunuz.
Performans açısından bakıldığında, bu muhtemelen en iyi sonuçları verecektir (test edilmemiş olsa da). Son derece uzun dizeler için, performans kazançları pencereyi düşürebilir.
function reverseString(str) {
var temp = '';
var i = str.length;
while (i > 0) {
temp += str.substring(i - 1, i);
i--;
}
return temp;
}
reverseString('dwayne');
3) Özyineleme
Bu çözümün ne kadar basit ve net olduğunu seviyorum. String.charAt ve String.substr yöntemlerinin, dize boş olana kadar her seferinde kendisini çağırarak üçlünün kendisini çağırmak için özyineleme kullanmak yerine boş bir dize döndüreceği farklı bir değerden geçmek için kullanıldığını açıkça görebilirsiniz. . Bu muhtemelen ikinci çözümden sonra ikinci en iyi performansı verecektir.
function reverseString(str) {
return (str === '') ? '' : reverseString(str.substr(1)) + str.charAt(0);
}
reverseString('dwayne');