Перевернуть строку в Javascript.

Методы String, рассматриваемые в этой статье, будут Split(), Reverse() и Присоединиться().

Основные вопросы по javascript будут касаться строк на собеседовании, поэтому мы хотим убедиться, что выучили эти лайфхаки со строками. Вы когда-нибудь удивлялись тому, как работают строковые методы и особенно этот фрагмент кода 🤔.

const stringToReverse = "DonkeyBonkey";

const reversedString =stringToReverse.split("").reverse().join("");

console.log(reversedString);

// output = "yeknoByeknoD"

Давайте узнаем, как методы javascript сделали нашу жизнь проще. Мы используем множество методов в javascript, таких как split(), reverse(), join(), substring(), charAt()и так далее. В этой статье мы возьмем из них несколько методов и посмотрим, как они работают у нас.

Метод, который мы рассмотрим:

1. расколоть
2. обеспечить регресс
3. присоединиться

Разделить()

Метод split принимает шаблон строки и подстроку путем поиска шаблона. В этой статье мы не будем использовать какие-либо строковые методы, предоставляемые javascript, но как 🤔 давайте разберемся. Метод Split принимает отступ, что означает пустые строки как argument, если вы передаете это как пустую строку, он разделяет все элементы в аргументе, который вы передаете, и возвращает в виде массива. Если вы оставите пробел в пустой строке, такой как « », то метод разделения разделяет все элементы, имеет элемент пустой строки в значении, которое вы передаете, и добавляет значения перед пустой строкой и вставляет в массив как значение и продолжается. Если отступ не передан, он объединит все элементы и вернет их как массив с одним значением.

const stringToBeSplitted = "Javascript string methods";

console.log(stringToBeSplitted.split("")); // ['J', 'a', 'v', 'a', 's', 'c', 'r', 'i', 'p', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 'm', 'e', 't', 'h', 'o', 'd', 's']
console.log(stringToBeSplitted.split(" ")); // ['Javascript', 'string', 'methods']
console.log(stringToBeSplitted.split()); // ['Javascript string methods']

// split the string without using string methods.

class Strings {
  constructor(stringToReverse) {
    this.stringToReverse = stringToReverse;
    this.splittedString = [];
    this.indexedString = "";
  }

  Split(indent) {
    if (this.splittedString.length > 0) this.splittedString = [];  
    if (typeof this.stringToReverse !== 'string') return "Not a string data stype!";  
    if (indent === undefined) {
        this.splittedString = [this.stringToReverse];
        return this.splittedString;
    } else if (indent === "") {
      for (let i = 0; i < this.stringToReverse.length; i++) {
        this.splittedString.push(this.stringToReverse[i]);
      }
      return this.splittedString;
    } else {
      for (let i = 0; i < this.stringToReverse.length; i++) {
        if (this.stringToReverse[i].valueOf() !== " ") {
          this.indexedString += this.stringToReverse[i];
          if (i === this.stringToReverse.length - 1)
            this.splittedString.push(this.indexedString);
        } else {
          this.splittedString.push(this.indexedString);
          this.indexedString = "";
        }
      }
      return this.splittedString;
    }
  }
}

const strings = new Strings(stringToBeSplitted);
console.log(strings.Split("")); // ['J', 'a', 'v', 'a', 's', 'c', 'r', 'i', 'p', 't', ' ', 's', 't', 'r', 'i', 'n', 'g', ' ', 'm', 'e', 't', 'h', 'o', 'd', 's']
console.log(strings.Split(" ")); // [ 'Javascript', 'string', 'methods' ]
console.log(strings.Split()); // [ 'Javascript string methods' ]

Реверс()

Обратный метод используется для обращения массива, который принимает массив в качестве аргумента, перебирает массив и меняет местами элемент слева направо. Этот метод был отсортирован с использованием алгоритма пузырьковой сортировки.

const arrayToReverse = [1,2,3,4,5];

console.log(arrayToReverse.reverse()); // [5, 4, 3, 2, 1]

// reverse the array without using reverse() method.

class Strings {
  constructor() {
    this.splitIndent;
    this.reversedArray = [];
  }

  Reverse(array) {
    let iteratrionTimes = array.length;
    for (let i = 0; i < iteratrionTimes; i++) {
      let temp = array[i];
      this.reversedArray.push(
        array[array.length - 1]
      );
      array[array.length - 1] = temp;
      array.pop();
    }
    return this.reversedArray;
  }
}

const strings = new Strings();
console.log(strings.Reverse([1,2,3,4,5])); // [5, 4, 3, 2, 1]

Присоединиться()

Метод соединения принимает массив в качестве аргумента, объединяет их в строку и возвращает ее. Берет шаблон массива и перебирает каждый элемент массива, используя алгоритм полного перебора. Отступ играет важную роль в этом методе, возвращаемая строка будет иметь отступ пробела, который мы передали в качестве аргумента. Если отступ не был передан, он будет преобразован из типа данных объекта, что означает из типа данных, определенного пользователем, в тип данных строки.

const arrayToJoin = [1,2,3,4,5];

console.log(arrayToJoin.join()); // '1,2,3,4,5'
console.log(arrayToJoin.join("")) // '12345'
console.log(arrayToJoin.join(" ")) // '1 2 3 4 5'


class Strings {
  Join(array, indent) {
    let joinedString = "";  
    let stringArr = String(array)
    if (indent === undefined) {
        return stringArr;
    } else if (indent === "") {
        for (let i = 0; i < stringArr.length; i++) {
            joinedString += i % 2 === 0 ? stringArr[i] : "";
        }
    } else {
        for (let i = 0; i < stringArr.length; i++) {
            joinedString += stringArr[i] === "," ? indent : stringArr[i]
        }
    }
     return joinedString
  }
}

const strings = new Strings();
console.log(strings.Join([1,2,3,4,5])); // '1,2,3,4,5'
console.log(strings.Join([1,2,3,4,5], "")); // '12345'
console.log(strings.Join([1,2,3,4,5], " ")); //'1 2 3 4 5'

Обратное преобразование строки без каких-либо строковых методов, предоставляемых Javascript

Вот полный код, который вы ищете, и этот код также можно оптимизировать, но я предоставил его бесплатно для лучшего понимания. Вы можете скопировать этот фрагмент кода и запустить этот код, чтобы узнать, как это работает 🤍.

const StringToReverse = "Donkey Bonkey";
console.log(StringToReverse.split("").reverse().join(""));

class Strings {
  constructor(stringToReverse) {
    this.splitIndent;
    this.stringToReverse = stringToReverse;
    this.splittedString = [];
    this.reversedArray = [];
    this.indexedString = "";
  }

  Split(indent) {
    this.splitIndent = indent;
    if (indent === "") {
      for (let i = 0; i < this.stringToReverse.length; i++) {
        this.splittedString.push(this.stringToReverse[i]);
      }
      return this;
    } else {
      for (let i = 0; i < this.stringToReverse.length; i++) {
        if (this.stringToReverse[i].valueOf() !== " ") {
          this.indexedString += this.stringToReverse[i];
          if (i === this.stringToReverse.length - 1)
            this.splittedString.push(this.indexedString);
        } else {
          this.splittedString.push(this.indexedString);
          this.indexedString = "";
        }
      }
      return this;
    }
  }

  Reverse() {
    let iteratrionTimes = this.splittedString.length;
    for (let i = 0; i < iteratrionTimes; i++) {
      let temp = this.splittedString[i];
      this.reversedArray.push(
        this.splittedString[this.splittedString.length - 1]
      );
      this.splittedString[this.splittedString.length - 1] = temp;
      this.splittedString.pop();
    }
    return this;
  }

  Join(indent) {
    let strArray = String(this.reversedArray);
    let reversedString = "";
    if (indent === undefined) return strArray
    else if (this.splitIndent === "") {
      for (let i = 0; i < strArray.length; i++) {
        reversedString += i % 2 === 0 ? strArray[i] : indent;
      }
    } else {
      for (let i = 0; i < strArray.length; i++) {
        reversedString += strArray[i] === "," ? indent : strArray[i];
      }
    }
    return reversedString;
  }
}

const strings = new Strings(StringToReverse);
console.log(strings.Split("").Reverse().Join(""));

Сводка

Эта статья в основном основана на том, как работают строковые методы. Строковые методы Javascript просты в использовании и делают наш код более чистым и понятным, в то же время нам, как разработчикам, необходимо знать, как эти методы работают. Спасибо, что прочитали эту статью ♡.