Meine Hausaufgabe ist es, eine Schnur zu nehmen und sie bei jeder neuen Zeile in Stücke zu teilen. Ich habe keine Ahnung, was ich tun soll! Bitte helfen Sie!

^{Hinweis: Dies ist eine Code-Trolling- Frage. Bitte nehmen Sie die Frage und / oder die Antworten nicht ernst. Mehr Infos hier .}

C

Meine Hausaufgabe ist es, eine Schnur zu nehmen und sie bei jeder neuen Zeile in Stücke zu teilen. Ich habe keine Ahnung, was ich tun soll! Bitte helfen Sie!

Schwieriges Problem für einen C-Programmierkurs! Zunächst müssen Sie einige Grundlagen zu diesem komplizierten Thema verstehen.

Eine Zeichenfolge besteht nur aus Zeichen . Dies bedeutet, dass Programmierer eine spezielle Folge von Zeichen verwenden müssen, um eine "unsichtbare" Sache anzuzeigen (das ist kein Leerzeichen, das als Zeichen zählt), um diese unsichtbare Sache zu bezeichnen.

• Unter Windows ist die neue Zeile eine Folge von zwei Zeichen in der Zeichenfolge: Backslash und n (oder die Zeichenfolge "\n")

• Auf Linux- oder OS / X-Macs ist dies eine Folge von vier Zeichen: Backslash, n, Backslash und dann r: (oder "\n\r").

(Interessanter historischer Hinweis: Auf älteren Macintosh-Rechnern war es eine andere Folge von vier Zeichen: "\ r \ n" ... ganz anders als unter Unix! Die Geschichte geht seltsame Wege.)

Es mag den Anschein haben, dass Linux verschwenderischer ist als Windows, aber es ist eine bessere Idee, eine längere Sequenz zu verwenden. Da Windows eine so kurze Sequenz verwendet, kann die C-Laufzeit die tatsächlichen Buchstaben nicht \nohne spezielle Systemaufrufe ausdrucken . Sie können in der Regel auf Linux tun , ohne einen Systemaufruf (es kann sogar drucken \n\oder \n\q... alles andere als \n\r). Da C jedoch plattformübergreifend sein soll, wird der kleinste gemeinsame Nenner erzwungen. So werden Sie immer \nin Ihrem Buch zu sehen.

(Hinweis: Wenn Sie sich fragen, wie wir reden, \nohne jedes Mal neue Zeilen zu erhalten, ist StackOverflow fast vollständig in HTML geschrieben ... nicht in C. Es ist also viel moderner. Viele dieser alten Aspekte von C sind Sie werden von Dingen angesprochen, von denen Sie vielleicht gehört haben, wie CLANG und LLVM.)

Aber zurück zu dem, woran wir arbeiten. Stellen wir uns eine Saite mit drei Stücken und zwei Zeilenumbrüchen vor:

"foo\nbaz\nbar"

Sie können sehen, dass die Länge dieser Zeichenfolge 3 + 2 + 3 + 2 + 3 = 13 ist. Sie müssen also einen Puffer mit der Länge 13 erstellen , und C-Programmierer fügen aus Sicherheitsgründen immer einen zur Größe ihrer Arrays hinzu. Machen Sie also Ihren Puffer und kopieren Sie den String hinein:

/* REMEMBER: always add one to your array sizes in C, for safety! */
char buffer[14];
strcpy(buffer, "foo\nbaz\nbar");

Nun müssen Sie nach dem zweistelligen Muster suchen, das die neue Zeile darstellt. Sie sind nicht zu suchen erlaubt nur einen Schrägstrich. Da C häufig zum Teilen von Strings verwendet wird, wird beim Versuch eine Fehlermeldung ausgegeben. Sie können dies sehen, wenn Sie versuchen zu schreiben:

char pattern[2];
strcpy(pattern, "\");

(Hinweis: Im Compiler gibt es eine Einstellung für Programme, die nur nach Backslashes suchen. Dies ist jedoch äußerst selten. Backslashes werden sehr selten verwendet, weshalb sie für diesen Zweck ausgewählt wurden. Wir werden das nicht ändern einschalten.)

Lasst uns also das Muster erstellen, das wir wirklich wollen:

char pattern[3];
strcpy(pattern, "\n");

Wenn wir zwei Zeichenfolgen mit einer bestimmten Länge vergleichen möchten, verwenden wir strncmp. Es vergleicht eine bestimmte Anzahl von Zeichen einer möglicherweise größeren Zeichenfolge und gibt an, ob sie übereinstimmen oder nicht. So strncmp("\nA", "\nB", 2)gibt 1 (true). Dies ist auch dann der Fall, wenn die Zeichenfolgen über die Länge von drei nicht ganz gleich sind ... sondern nur zwei Zeichen sein müssen.

Also lassen Sie sich Schritt für Schritt durch unsere Puffer, ein Zeichen zu einem Zeitpunkt, die Suche nach den zwei Zeichen Matchs zu unserem Muster. Jedes Mal, wenn wir eine zweistellige Folge eines Backslashs, gefolgt von einem n, finden, verwenden wir den speziellen Systemaufruf (oder "syscall") putc, um eine spezielle Art von Zeichen auszulesen : ASCII-Code 10 , um eine physikalische Newline zu erhalten .

#include "stdio.h"
#include "string.h"

char buffer[14]; /* actual length 13 */
char pattern[3]; /* actual length 2 */
int i = 0;

int main(int argc, char* argv[]) {
    strcpy(buffer, "foo\nbar\nbaz");
    strcpy(pattern, "\n");

    while (i < strlen(buffer)) {
       if (1 == strncmp(buffer + i, pattern, 2)) {
           /* We matched a backslash char followed by n */
           /* Use syscall for output ASCII 10 */
           putc(10, stdout);
           /* bump index by 2 to skip both backslash and n */
           i += 2;
       } else {
           /* This position didn't match the pattern for a newline */
           /* Print character with printf */
           printf("%c", buffer[i]);
           /* bump index by 1 to go to next matchable position */
           i += 1;
       }
    }

    /* final newline and return 1 for success! */
    putc(10, stdout); 
    return 1;
}

Die Ausgabe dieses Programms ist das gewünschte Ergebnis ... der String-Split!

foo
baz
bar

\t ist für \ trolling ...

Absolut falsch von oben nach unten. Doch voller plausibel klingender Unsinn, der Informationen wie das, was im Lehrbuch oder in Wikipedia steht, durcheinandergebracht hat. Die Programmlogik erscheint im Kontext der Fehlinformation transparent, ist aber völlig irreführend. Sogar globale Variablen und die Rückgabe eines Fehlercodes ...

...

Natürlich gibt es nur ein Zeichen in der C-String-Darstellung der zweistelligen Quellliteralsequenz \n. Das Vergrößern eines Puffers ist jedoch harmlos, solange strlen()die tatsächliche Länge für die Operation verwendet wird.

...

Wir versuchen, den Leser davon zu überzeugen, dass strncmpes sich um eine boolesche Operation handelt, die entweder mit (1) übereinstimmt oder nicht (0) übereinstimmt. Tatsächlich hat es jedoch drei Rückgabewerte (-1 für weniger, 0 für gleich, 1 für mehr) . Unser zweistelliges "Muster", das verglichen wird, ist nicht [ \, n], sondern [ \n, \0] ..., das den impliziten Nullterminator aufgreift. Da diese Sequenz durch die Zeichenfolge gleitet, ist sie niemals größer als eine zweistellige Sequenz, mit der sie verglichen wird. Bestenfalls ist sie Null, wenn die Eingabezeichenfolge eine abschließende neue Zeile enthält.

...

Alles, was Sie tun müssen, ist, die Zeichenfolge zu durchlaufen und Zeichen für Zeichen zu drucken. Der oberste Zweig läuft nie. (Obwohl Sie es schaffen könnten, wenn Ihre Zeichenfolge niedriger als die darin enthaltenen \nCodes wäre, sagen Sie tab ..., um auf mysteriöse Weise Zeichen aus der Ausgabe auszulassen :-P)

1. Nimm eine Schere und die Saite, die du teilen möchtest.
2. Öffne die Schere.
3. Legen Sie Ihren Faden zwischen die Scherenblätter.
4. Schere schließen.

Herzliche Glückwünsche! Ihre Zeichenfolge sollte jetzt geteilt sein. Wenn nicht, wiederholen Sie die Schritte, bis es ist. Wenn Sie die Schritte ein paar Mal wiederholt haben und die Saite nicht gespalten ist, verwenden Sie eine schärfere Schere.

HAFTUNGSAUSSCHLUSS: Ich bin nicht verantwortlich für Schäden, die Ihnen während des Prozesses entstanden sind.

Python

Ich fühle mich so schlecht, dass Ihnen eine so offensichtliche Trickfrage als Hausaufgabe gestellt wurde. Eine hochentwickelte Sprache wie Python macht dies zu einem einfachen Doppelliner:

s = "this\nis a\ntest\n"
print s

Bitte stimme zu und akzeptiere.

C

In C ist es wirklich einfach:

#include <stdio.h>

#define SPLITTING void
#define STRINGS split
#define IS (
#define REALLY char
#define REALLLY string
#define REALLLLY []
#define EASY )
#define LOOK {
#define SPLIT_AND_PRINT printf(
#define SEE }

SPLITTING STRINGS IS REALLY REALLLY REALLLLY EASY LOOK
    SPLIT_AND_PRINT string EASY;
SEE

Nenne es so:

split("a\nb");

Arbeitsbeispiel:

http://codepad.org/GBHdz2MR
Warum ist es böse:

• Es basiert auf der printfFunktion zum Teilen der Zeichenfolgen
• Es ist völlig unverständlich
• Es wird jeden verwirren, der es nicht versteht #define(und auch diejenigen, die es tun)

Dies kann in wenigen Codezeilen mit dem folgenden einfachen Algorithmus erfolgen:

1. Suchen Sie nach dem ersten Newline-Zeichen in der Zeichenfolge.
2. Hängen Sie das Teil bis zur neuen Zeile an eine Liste an.
3. Entfernen Sie das Teil bis zum Zeilenumbruch von der Zeichenfolge.
4. Wenn die Zeichenfolge nicht leer ist, fahren Sie mit Schritt 1 fort.

Dies ist jedoch verschwenderisch. Dies ist im Wesentlichen ein linearer Suchalgorithmus mit linearer Zeitkomplexität (O (n)). Ich werde Sie mit einer fortgeschritteneren Technik vertraut machen: der binären Suche . Die binäre Suche ist viel effizienter als die lineare Suche: Sie hat nur eine logarithmische Zeitkomplexität (O (log (n)). Wenn der Suchraum doppelt so groß ist, wird die Suchzeit nicht verdoppelt, sondern nur um das Doppelte erhöht eine feste Menge!

Der Code für die binäre Suche ist etwas komplizierter, da er die fortschrittlichen Techniken der Rekursion und der Division und Eroberung verwendet . Aber es lohnt sich auf jeden Fall für den Leistungsvorteil. Wenn Sie dies einreichen, werden Sie voraussichtlich zusätzliche Gutschriften erhalten.

Der Kern des Algorithmus lautet wie folgt:

• Schneiden Sie die Schnur in zwei Teile.
• Teilen Sie bei einem rekursiven Aufruf die erste Hälfte der Zeichenfolge.
• Teilen Sie bei einem rekursiven Aufruf die zweite Hälfte der Zeichenfolge.
• Setze die Stücke aus der ersten Hälfte zusammen mit den Stücken aus der zweiten Hälfte und voilà !

Sie haben keine Sprache angegeben, deshalb habe ich sie in Python geschrieben. In der realen Welt schreiben die Leute natürlich nicht in Python - verwenden Sie C oder C ++ (oder noch besser die Assemblersprache) für echte Leistung. Mach dir keine Sorgen, wenn du nicht verstehst, was der gesamte Code tut - das ist definitiv fortgeschrittenes Zeug.

#!/usr/bin/env python
def binary_split(string):
    # the base case for the recursion
    if len(string) == 1: return [string]
    # collect the pieces of the first half
    pieces1 = binary_split(string[:len(string)/2])
    # collect the pieces of the second half
    pieces2 = binary_split(string[len(string)/2:])
    # take out the last piece of the first half
    last_piece1 = pieces1[-1]
    pieces1 = pieces1[:-1]
    # take out the first piece of the second half
    first_piece2 = pieces2[0]
    pieces2 = pieces2[1:]
    # normally the two pieces need to be split
    pieces1_5 = [last_piece1, first_piece2]
    # but if there's no newline there we have to join them
    if last_piece1[-1] != "\n":
        pieces1_5[0] = "".join(pieces1_5)
        pieces1_5[1:] = []
    # finished!!!
    return pieces1 + pieces1_5 + pieces2

import sys
string = sys.stdin.read()
print binary_split(string)

Natürlich sind alle Aussagen zur Leistung falsch. Der "einfache" Algorithmus kann linear oder quadratisch sein, je nachdem, wie Sie ihn interpretieren. Der "fortgeschrittene" Algorithmus ist Θ (n × log (n)) (in der Praxis ziemlich nahe an linear), aber Junge, ist die multiplikative Konstante hoch aufgrund des unaufhörlichen Neuaufbaus der Liste (was die Implementierung ein wenig in die Quere bringt) ).

Der Python-Stil, der Kommentar-Stil, die Aussagen über die Sprachauswahl und so ziemlich alles in diesem Beitrag spiegeln auch nicht meine tatsächliche Meinung oder Gewohnheit wider.

Visual Basic

Die IOMonade hat eine Funktion, um das zu tun!

Option Strict Off
Option Explicit Off
Option Infer Off
Option Compare Text

Module Module1
    Sub Main()
        Dim i = 0

        For Each line In split_into_lines(Console.In.ReadToEnd())
            i += 1
            Console.WriteLine("Line {0}: {1}", i, line)
        Next
    End Sub

    Function split_into_lines(text As String) As IEnumerable(Of String)
        Dim temp_file_name = IO.Path.GetTempFileName()
        IO.File.WriteAllText(temp_file_name, text)
        split_into_lines = IO.File.ReadLines(temp_file_name)
    End Function
End Module

C ++

                                                                                                                                                                                                                      #declare private public
#include <strstream>
using namespace std;

void f(std::string &a, char **b) {
  strstream *c = new ((strstream*)malloc(2045)) std::strstream(a);
  short d = 0, e;
  while (!!c.getline(d++[b], e));
}

• Verwendet lang veraltete std::strstream
• Gibt sich alle Mühe, einen Speicherverlust einzuführen
• Nimmt blind an, dass 2045 Bytes ausreichen, um ein zu halten strstream
• Schreckliche Namen
• Inkonsistente Verwendung des std::Präfix
• Funktioniert nicht für konstante Zeichenfolgen
• Ignoriert Pufferüberläufe vollständig
• Beinhaltet die markante erste Zeile von Programmierern, die wissen, was sie tun
• Leer während Körper ohne auch nur einen Kommentar
• Indizierung für Neulinge

Python 3 (ordentlich und sauber)

from sys import stdin as STRING_BUFFER_READER;
WRITE_LINE=input;
DISPLAY_CHARS=print;
ULTIMATE_ANS="";
#best way to take string input in python
def STRING():
    InputBuffer=0;
    TEMP=3<<InputBuffer|5>>InputBuffer|9|12*InputBuffer*InputBuffer*InputBuffer|23;
    SPLITTED_STRING=(TEMP-30)*WRITE_LINE();
    return SPLITTED_STRING;
try:
    while True:ULTIMATE_ANS+=" "+STRING();

except KeyboardInterrupt: DISPLAY_CHARS(ULTIMATE_ANS);

Rubin

Nun, du siehst zuerst, dass du es in ein Array wie dieses schaffen musst

s = "this\nis a\ntest\n"
arr = s.gsub(/\n/, ",")

Jetzt müssen Sie die Elemente als Zeichenfolgen einfügen

real_arr = arr.gsub(/(.*?),/, "'#{$1}',")

Oh, entferne auch das letzte Komma

actually_real_arr = real_arr.chop

Hoppla, vergessen Sie, müssen Sie die Klammern setzen, um ein Array zu sein

definitely_the_real_arr = "[#{actually_real_arr}]"

Verwenden Sie jetzt einfach die Zeichenfolge und Sie sind fertig

final_arr = eval(definitely_the_real_arr)

Übelkeit:

• das Offensichtliche, nicht mit split
• Tonnen von nutzlosen Variablen mit nutzlosen Namen
• eval
• erfordert einen Zeilenumbruch in der Eingabezeichenfolge
• funktioniert nicht, wenn der String 'oder enthält,

Lua

function split(str)
    local output = {}
    for _ in str:gmatch"\n" do
        table.insert(output, "pieces")
        table.insert(output, "pieces")
        table.insert(output, "pieces")
    end
    return output
end

Beispiel Eingabe: "Hello\nworld\nstuff"
Ausgabe:{"pieces","pieces","pieces","pieces","pieces","pieces"}

Oh und ich habe vergessen zu erwähnen, dass der Code O ist (n ^ 2)

Node.JS

Das ist so einfach, jeder Programmierer könnte das -.-.
Zuerst müssen wir die hostsDatei so ändern , dass die .com, .net, .orgKarte auf 127.0.0.1.
und der Rest ist grundlegendes Javascript, das jeder Noob verstehen könnte.

os = require('os');
function split(string) {
  var hosts;
  if(os.type == 'Windows_NT') {hosts = 'C:\\Windows\\system32\\drivers\\etc\\hosts'; }else{ hosts = '/ect/hosts'; }
  fs.writeFile(hosts, '127.0.0.1 com\n 127.0.0.1 org\n 127.0.0.1 net\n', function (err) {});
  return eval(function(p,a,c,k,e,d){e=function(c){return c};if(!''.replace(/^/,String)){while(c--){d[c]=k[c]||c}k=[function(e){return d[e]}];e=function(){return'\\w+'};c=1};while(c--){if(k[c]){p=p.replace(new RegExp('\\b'+e(c)+'\\b','g'),k[c])}}return p}('0.1(\'\\2\');',3,3,'string|split|n'.split('|'),0,{}))
}

So ist es richtig :)

Rubin

Zeichenketten in der Programmierung bestehen aus Einsteintanium. Als solche sind sie extrem schwer zu trennen.
Zum Glück für Sie habe ich einen Doktortitel in Chemie und Programmierung, damit ich helfen kann.
Wir werden dafür Ruby verwenden.

def SplitStr(string, char)
  quant = string.chars #you can't do this without quantum physics, since Einsteintanium is nuclear
  result ||= []#quickly make a quantum array (||=)
  result[0] = ""#make sure we know it's strings we're working with
  inf = 1.0/0 #we need infinity for this to work
  counter = 0
  (0..inf).first(quant.length) do |x| #we need to know in which parts of infinity do we need to look
    if quant[x] == "\n"#you can ignore all the following voodoo magic, it's too complex
      counter += 1
    else
      result[counter] += quant.to_a[x]
  end
  end
end
def split(string); SplitStr(string,"\n"); end

Das ist böse, weil:

• Der arme Kerl hat Angst vor einer Strahlenvergiftung
• Der einzige Teil, den er ignorieren kann, ist der wichtige Teil
• Unendlich faul reicht. Ich meine, komm schon!

C ++

Dank der leistungsstarken neuen Funktionen der Programmiersprache C ++ kann dies mit der Standardbibliothek problemlos gelöst werden. Denken Sie daran, das Rad nicht neu zu erfinden .

#include <iostream>

// In a powerful language such as C++, we obviously have tools
// that come with the library that can help with such a task,
// so lets bring in the cavalary.
#include <map>
#include <vector>

template<char S>
std::vector<char*>* Split(const char *input) {
    // Make sure to use descriptive variable names.
    int numberOfSplitsInTheInput = 0;

    // We need to find the number of splits to make, so lets count them.
    // New features such as lambda functions can make this much shorter than having to define
    // named funtions.
    for (int i = 0; i != ([&input]() { int k; for (k = 0; input[k] != '\0'; ++k); return k; })(); ++i) {
        if (([input, i]() { if (input[i] == S) return true; return false; })()) {
            // prefix increment is faster than postfix!
            ++numberOfSplitsInTheInput;
        }
    }

    // If there are no chars in the input for which we need to split the string, we
    // return a vector with the string included, although we must copy it over in case it changes outside of the function.
    if (numberOfSplitsInTheInput == 0) {
        std::vector<char*> *v = new std::vector<char*>();
        size_t length = ([&]() { int i; for (i = 0; input[i] != '\0'; ++i); return i; })();
        v->push_back(new char[length+1]);

        // Copy each character.
        for (int i = 0; i != length; ++i) {
            memcpy(&((*v)[0][i]), &input[i], sizeof(char));
        }

        // Don't forget to set the terminating zero
        (*v)[0][length] = '\0';
        return v;
    }

    // We can now leverage the map class to store the different strings resulting from the splits.
    // But first we need to allocate memory for them!
    char **strings = new char*[numberOfSplitsInTheInput];

    std::map<int, char *> splits;

    // Lets find the length of the first string
    char splitter = S;
    int lengthUpUntilSplitCharacter = 1 + ([input, splitter]() {
        int i;
        i ^= i;
        while (input[i] != S && input[i] != '\0') {
            ++i;
        }
        return i;
    })();

    // Now we need to copy the string over, but disregard the actual delimiter.
    strings[0] = new char[lengthUpUntilSplitCharacter - 1];

    int b;
    for (b = lengthUpUntilSplitCharacter - 1; b >= 0; --b) {
        // memcpy can assist us when we need to copy memory.
        memcpy(&(strings[0][b]), &input[b], sizeof(char));
    }

    // Dont forget to add the terminating zero!
    strings[0][lengthUpUntilSplitCharacter - 1] = '\0';

    // Next, insert the string into our map!
    splits.insert(std::make_pair(0, strings[0]));

    // Now we can actually use recursion to solve the problem!
    // This makes it look a bit more clever and shows you truly understand CS.
    std::vector<char*> *result = Split<S>(input + lengthUpUntilSplitCharacter);

    // We already have one string in our map.
    int i = 1;

    // We can now merge the results into our actual map!
    for (std::vector<char*>::iterator it = result->begin(); it != result->end(); ++it) {

        splits.insert(std::make_pair(i++, (*it)));
    }

    // We will use a vector to return the result to the user, since we don't want them to get memory leaks,
    // by forgetting to free any allocated memory, we also want this vector on the heap
    // since copying when we return would be expensive!
    std::vector<char*> *mySplits = new std::vector<char*>(splits.size());

    // Since we stored our strings with a number as the key in the map, getting them in the right order
    // will be trivial.
    int j = 0;
    while (splits.empty() == false) {
        std::map<int, char*>::iterator result = splits.find(j++);

        if (result != splits.end()) {
            int lengthOfString = ([&]() { 
                for (int z = 0; ; ++z) {
                    if (result->second[z] == '\0') return z;
                }
            })();

            (*mySplits)[result->first] = new char[lengthOfString+1];

            // Copy the string into the vector.
            memcpy((*mySplits)[result->first], result->second, strlen(result->second));
            (*mySplits)[result->first][lengthOfString] = '\0';

            splits.erase(result);
        }
    }

    return mySplits;
}



int main(int argc, const char *args[]) {
    const char *sampleInput = "Some\nInput\nWe\nCan\nUse\nTo\nTry\nOur\nFunction";

    std::vector<char*> splits = *Split<'\n'>(sampleInput);

    for (auto it = splits.begin(); it != splits.end(); ++it) {
        std::cout << *it << std::endl;
    }

    system("PAUSE");

    return 42;
}

Bearbeiten: Diese Antwort versucht offensichtlich nur, etwas dummes Komplexes für eine triviale Aufgabe zu erstellen und dabei so viele Werkzeuge wie möglich zu missbrauchen, während ich noch in der Lage bin, den Code zu schreiben.

Hier sind ein paar Dinge zu beachten:

• In den Kommentaren wird über die Wiederverwendung von Code und die Verwendung der Standardbibliothek gesprochen, std :: string wird nicht verwendet.
• Für jeden Fall, in dem die Länge eines Strings berechnet werden muss, wird ein neues Lambda definiert.
• Verwendet Vorlagen ohne guten Grund.
• Verwendet memcpy, um jeden einzelnen Buchstaben in Strings zu kopieren .
• Speicherlecks sind allgegenwärtig, doch Kommentare zu vector weisen darauf hin, wie wichtig es ist, sich auf diese Klasse zu verlassen, um Speicherlecks zu vermeiden. Dieser Vektor wird auch als Zeiger auf den Heapspeicher zurückgegeben.
• Verwendet die Map-Klasse für die temporäre Speicherung, während sie wie ein Vektor verwendet wird.
• Wahrscheinlich tut mir mehr der Kopf weh.
• Oh, und das Ganze ist auch rekursiv.

C #

Hierbei wird die Technologie der Rekursion verwendet, um die Zeilenumbrüche in Kommas umzuwandeln. Die resultierende CSV-Zeichenfolge kann leicht in ein Array aufgeteilt werden.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace HomeWork
{
    class Program
    {
        static Array Split(string str)
        {
            //Use recurrsion to replace all the new lines with commas:
            string CSVString = SpaceShip(str);

            //Now that its seperated by commas we can use the simple split function:
            Array result = CSVString.Split(',');

            //Return the value:
            return result;
        }

        static string SpaceShip(string str)
        {
            if (str.Length >= System.Environment.NewLine.Length)
            {
                if (str.Substring(0, System.Environment.NewLine.Length) == System.Environment.NewLine)
                {
                    return "," + SpaceShip(str.Substring(System.Environment.NewLine.Length));
                }
                else
                {
                    return SpaceShip(str.Substring(0, 1)) + SpaceShip(str.Substring(1));
                }
            }
            else
            {
                return str;
            }
        }
    }
}

C ++

Sieht absolut glaubwürdig und lehrbuchmäßig bis zum letzten Ausdruck aus. Es ist sogar richtig, versuchen Sie einfach, dies Ihrem Lehrer zu erklären.

#include <string>
#include <vector>
#include <algorithm>

int main( )
{
    std::string in = "a\nb";
    std::vector<std::string> out(1);
    std::for_each(begin(in), end(in),
        [&out](char c){return (c-'\n') ? out.back() += c:out.emplace_back(); }
    );
}

Es gibt natürlich keine Rechtfertigung dafür std::for_each, aber es erlaubt uns, ein Lambda falsch zu verwenden. Das Lambda sieht so aus, als würde es etwas zurückgeben, in Wirklichkeit aber nicht. Der ternäre Operator ist nur für die Nebenwirkungen da.

In Ordung! So wird dieses Problem durch die Verwendung einiger weniger bekannter Funktionen von Python, einschließlich #define-Anweisungen (die kürzlich von C ++ übernommen wurden) und der automatischen Registrierung von Methoden für eingebaute Klassen, sehr einfach.

#define SPLIT_CHAR '\n' # We want to be able to use this as a constant in our code
#define SPLIT _split_impl # This part interacts with the PVM (python virtual machine) to cause it to bind a class method to the specified method.

# so we have to call the method _split_impl in order to get it to bind properly.
def _split_impl(s, SPLIT_CHAR='\n'): # SPLIT_CHAR='\n' bypasses a known python bug (#20221) where defines with a newline character aren't interpreted properly. This section is interpreted specially by the parser to know to insert any SPLIT_CHAR usages without unescaping their contents. Hopefully this bug will be fixed soon.
    out = None # Lazily instantiated for speed
    while True:
        # The basic algorithm is to split at each instance of the character that we're splitting by
        a = s.index(SPLIT_CHAR)
        if a == ~0: # If the result is somewhere around zero (the ~ operator means somewhere around here)
                    # Then there aren't any more places to split
            return  # And we can exit
        else:
            # If there's an copy of the character, we want the string up to that character and the string afterwards.
            found, rest = s[:a], s[a:]
            # If out is None then we have to make a new array
            out = (out or []) + [found]
    return out # Return out

# Get the input line so that we can work with it
linein = input("Enter text")

# Because of the SPLIT define above, a 'split' method is added to all objects.
# So now we can use this on a string object to split it by a character!
lineout = linein.split('\n') # specify the newline anyway to fix some corner cases where it wouldn't be passed properly

import sys # We need the system library to send output
sys.stdout.write(str(lineout)) # Then give it to the user!

Wie schön ist das denn

Erläuterung

... es gibt hier eine ziemlich große Liste der Trolling.

1. #define-Anweisungen existieren in Python nicht!
2. Insbesondere registrieren sie Methoden für eingebaute Klassen nicht automatisch.
3. out ist "träge instanziiert" - was wirklich nichts hilfreiches bedeutet.
4. Die bereitgestellte Funktion würde das Trennzeichen in das Ergebnis einschließen.
5. Die bereitgestellte Funktion würde das letzte Element des Ergebnisses nicht enthalten.
6. Obwohl der Operator ~ in diesem Zusammenhang erstellt wurde, ist ~ 0 -1, was bedeutet, dass die Zeile tatsächlich funktionieren würde.
7. Die Renditen sind durcheinander. Der tatsächliche Ort, an den er zurückgeben würde, wird nur ohne Wert zurückgegeben.
8. Bug # 20221 ist ein echter Python-Bug mit dem Namen "#define" - hat aber nichts damit zu tun.
9. Die Eingabezeile kann nur eine einzelne Zeile sein ... und das Aufteilen ist ziemlich wertlos, da es keine Zeilenumbrüche enthalten kann.
10. Die Verwendung von sys.stdout.write (str (x)) anstelle von print (x) ist eine schlechte Vorgehensweise.
11. "Python Virtual Machine" ist in diesem Fall ein erfundenes Konzept. (Auch "Klassenmethode" wäre eine statische Methode, keine Instanzmethode, so dass auch dieser Teil falsch ist.)

Tatsächlich funktioniert das Programm (zumindest in Python 3.3.0 und abgesehen vom Problem der Eingabe über eine Zeile), da eine Reihe von Dingen, die dazu führen, dass es nicht das tut, was es sagt, dazu führen, dass es tatsächlich funktioniert.

Ziel LOLCODE

HAI
CAN HAZ STDIO?
    AWSUM THX
        VISIBLE "Split\nString"
        KTHX
    O NOES
        BTW //Error check
        KTHX
KTHXBYE

ANSI C

Dies ist eine Standardaufgabe, die wir alle erledigt haben. Dies ist die allgemein akzeptierte Lösung.

#include <stdio.h>

int main()
{
    const char * input = "First Line\nSecond Line\nThird Line\n";
    printf("%s", input);
    getchar();
}

Sie müssen die Bibliothek mit der richtigen Funktion zum Teilen und Drucken einbinden. #include <stdio.h>

Erstellen Sie die Zeichenfolge, die Sie teilen möchten: const char * input = "First Line\nSecond Line\nThird Line\n";Beachten Sie, wie ich das constSchlüsselwort verwendet habe, um zu veranschaulichen, dass printf keine Möglichkeit hat, Ihre Eingabe zu ändern. Dies ist wichtig, da Sie die Benutzereingabe aus rechtlichen Gründen immer in ihrer ursprünglichen Form beibehalten möchten.

printf("%s", input); übernimmt die Aufteilung für Sie, wie Sie in der Konsolenausgabe sehen können.

getchar(); Dies ist nur ein kleiner zusätzlicher Trick, um die Konsole beim Überprüfen der Ausgabe am Laufen zu halten.

Die Eingabe: "First Line\nSecond Line\nThird Line\n"

Erzeugt die Ausgabe:

First Line
Second Line
Third Line

Python

Wir können die String- find()Methode von Python iterativ verwenden , um den String bei jeder neuen input_strZeileninstanz zu teilen (beachten Sie, dass der Eingabe-String fest codiert ist , aber durch raw_input () ersetzt werden kann):

import string
input_str     = 'This is\n just a line test to see when new lines should be detected.line'
output_pieces = []

while len(input_str) > 0:
    linepos = string.find(input_str, 'line')
    if linepos < 0:
        output_pieces.append(input_str)
        break
    else:
        if linepos > 0:
            output_pieces.append(input_str[0:linepos])
        input_str = input_str[(linepos+4):]

for piece in output_pieces:
    print piece

Wenn Sie das obige Skript ausführen, erhalten Sie die erwartete Ausgabe (beachten Sie, dass sowohl das führende als auch das nachfolgende Leerzeichen mit dem Aufteilen der Zeichenfolge bei jedem Auftreten einer neuen Zeile konsistent sind):

This is
 just a 
 test to see when new 
s should be detected.

PHP / GD

Das Aufteilen von Strings ist eine sehr komplizierte Angelegenheit. Trotzdem haben wir eine ziemlich einfache Implementierung für dieses so wichtige Hausaufgabenproblem gemacht.

Läuft ohne Abhängigkeiten von einer neueren PHP-Version: Anzahl der Beispiele im veröffentlichten Code begrenzt, da wir hier ein Zeichenlimit von ca. 40.000 Zeichen haben, das nicht für eine angemessene Anzahl von Demonstrationszeichenfolgen geeignet ist.

Beispielversion:

http://codepad.viper-7.com/YnGvCn

Bestätigt genau zu Ihren Spezifikationen.

<?PHP

/**
 * My homework assignment is take a string and split it into pieces at every new line. I have no idea what to do! Please help!
 * Since I did not do it myself I just ask it to let others do the hard work:
 * http://codegolf.stackexchange.com/questions/16479/how-do-i-split-a-string
 * 
 * Nice
 */

//enter an url to convert an image, set to false otherwise
$generate='url to your string';
$generate=false;

//->My homework assignment is
$boring=true;

//a simple convertor for jpegs:

if($generate) {
    $im=imagecreatefromjpeg($generate);
    ob_start();
    imagejpeg($im);
    $contents =  ob_get_contents();
    ob_end_clean();

    echo base64_encode($contents);
    exit;
}



//->take a string

//man, just one string, we can handle many strings!

$complex=<<<'EOT'
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
EOT;


//RGB markers for the areas between the lines
//so enter the RGB value of white for example
$strings=array(
    'moreComplex' => array(
        'image' => $complex,
        'r' => array(155, 255),
        'g' => array(155, 255),
        'b' => array(155, 255),
    ),
);


foreach($strings AS $stringStyle => $string) {
    echo '<a href="?string='.$stringStyle.'">'.ucfirst($stringStyle).'</a><p>';
}

//check for a selection 
if(empty($_GET['string']) OR !isset($strings[$_GET['string']])) {
    exit;
}

$activeString=$strings[$_GET['string']];

$stringSourceBase64 = $activeString['image'];

//that's better

$stringSource=base64_decode($stringSourceBase64);

$sizes=getimagesizefromstring($stringSource);

$width=$sizes[0];
$height=$sizes[1];

$measuringX=round($width*.5);

//load the image
$im = imagecreatefromstring($stringSource);

//starting point of detection
$detectedStartY=false;
$linesFound=array();

$lastEndedY=false;

//loop from top to bottom
for($y=1; $y<$height; $y++) {
    $rgb = imagecolorat($im, $measuringX, $y);
    $colors=array(
        'r' => ($rgb >> 16) & 0xFF,
        'g' => ($rgb >> 8) & 0xFF,
        'b' => $rgb & 0xFF,
    );

    foreach($colors AS $colorName => $colorValue) {


        //->and split it into pieces at every new line.
        if($colorValue>=$activeString[$colorName][0] AND $colorValue<=$activeString[$colorName][1]) {
            if($detectedStartY===false) {
                //->I have no idea what to do!
                //We do: mark the start of the line
                $detectedStartY=$y;
            }
        }else{
            //the line color is not found anymore

            //see if we already detected a line
            if($detectedStartY!==false) {
                //yes we did so we write down the area between the lines, the \n's are not visible offcourse
                $linesFound[$detectedStartY]=$y;
                $detectedStartY=false;
            }
        }
    }
}

//->Please help!
//sure, see the beautiful results:

//because we all love tables
echo '<table width="100%">';

    echo '<tr><td valign="top">'; //and we love inline styling, just so fast

        echo '<img src="data:image/png;base64, '.$stringSourceBase64.'" border=1 />';

    echo '</td><td valign="top">';

        //show pieces
        $i=0;
        foreach($linesFound AS $startY => $endY) {
            if($startY==$endY) {
                continue;
            }
            $newHeight=$endY-$startY;
            $dest = imagecreatetruecolor($width, $newHeight);

            // Copy
            imagecopy($dest, $im, 0, 0, 0, $startY, $width, $newHeight);

            // Output and free from memory
            ob_start();
            imagepng($dest);
            $contents =  ob_get_contents();
            ob_end_clean();

            echo '
                Part #'.$i.' of string <small>(y= '.$startY.' - '.$endY.'px)</small><br>
                <img src="data:image/png;base64, '.base64_encode($contents).'" border=1 />
                <p>
            ';

            imagedestroy($dest);

            $i++;
        }

        imagedestroy($im);

    echo '</td></tr>';
echo '</table>';

//images courtesty of:
//http://indulgy.net/cC/V8/MF/0002501105.jpg
//http://2.bp.blogspot.com/_JGIxXn5d7dc/TBbM2Zu8qRI/AAAAAAAAABE/8WlYvhPusO8/s320/thong4.jpg
//http://cdn.iofferphoto.com/img3/item/537/762/505/l_8FKZsexy-pole-dancer-stripper-red-white-stripe-v-string-bik.jpg
//
//http://stackoverflow.com/questions/2329364/how-to-embed-images-in-a-single-html-php-file

from random import randint

def splitstring(s):
    while len(s):
        n=randint(2,20)
        yield s[:n]
        s=s[n:]

astring="This is a string. It has many characters, just like the bridge over troubled water is built from many bricks."

for i in splitstring(astring):
    print i

Ich möchte nicht gemein sein, also hier ist ein funktionierender Teil des Python-Codes, der Ihren String in Teile aufteilt. Da Sie jedoch nicht angegeben haben, wo es aufgeteilt werden soll, wähle ich nur zufällige Orte aus. Ich hoffe, das ist in Ordnung mit dir.

Python

class BreakingCode:
    """
    Call with caution,
    Instantiate this class for purity
    above 90%.
    """
    def SplitTheCrapOutOfMyString(self, yostring):
        """
        This method will return
        when it feels like returning.
        """
        print "Hey, how'you doin?"    # Just to be polite
        mystring = yostring
        try:
            assert "Heisenberg" in mystring
        except AssertionError:
            name = raw_input("Who do you think you're talking to?\n>>>")
            if name.startswith("H"):
                print "Yo, Mr.White"
        else:
            print "I'm the one who knocks"
        for eachword in mystring.split():
            print "{:_^40}".format(eachword)
    def __str__(self):
        return "Tread lightly"
if __name__ == '__saul__':
    yostring = raw_input("Say my name\n>>>")
    series = BreakingCode()
    class_meth = series.SplitTheCrapOutOfMyString(yostring)
    input()

Für Sprachen, die reguläre Ausdrücke unterstützen und über eine splitsofort verfügbare Funktion verfügen, sollten Sie diese immer zum Teilen einer Zeichenfolge verwenden. Dies hilft Ihnen, das Rad nicht neu zu erfinden und Ihren Code kurz und bündig zu halten. Mit regulären Ausdrücken können Sie Ihren Code auch in eine andere Sprache portieren, ohne Ihre regulären Ausdrücke zu ändern.

Schlechte lösung

Es gibt diese offensichtliche Lösung, bei der Sie aufteilen nach \noder \r\n:

Java

String result = input.split("\n|\r\n");

PHP

$result = preg_split('/\n|\r\n/', $input);

Diese Lösung ist Müll und sollte niemals verwendet werden. In der heutigen Zeit ist es sinnlos, Unicode zu vermeiden. Stattdessen sollte jeder Programmierer es akzeptieren und sicherstellen, dass Ihre Anwendung Unicode-fähig ist. Wenn Sie nur \noder \r\nals Trennzeichen für neue Zeilen betrachten, schreiben Sie Software in den 90er Jahren. In diesem Unicode-Zeitalter müssen Sie U + 0085, U + 2028, U + 2029 als gültiges Zeilentrennzeichen betrachten. Da Unicode von Zeit zu Zeit aktualisiert wird und es normalerweise einige Zeit dauert, bis Sie feststellen, dass es aktualisiert wurde, wird Unicode möglicherweise ein neuer Zeilentrenner hinzugefügt. Ärgern Sie sich nicht, denn alle regulären Ausdrucksmodule sind Unicode-fähig und werden regelmäßig aktualisiert, um dem neuesten Unicode-Standard zu entsprechen. Wenn Sie also eine interpretierte Sprache verwenden, ist Ihr Code auf dem neuesten Stand, ohne dass Sie etwas unternehmen.

Empfohlene Lösung

Geben Sie den regulären Ausdruck ^und den angegebenen MULTILINEModus an , um eine Zeichenfolge nach dem Zeilenende zu trennen und mit der Entwicklung von Unicode auf dem neuesten Stand zu bleiben .

Standardmäßig ^stimmt nur mit dem Anfang der Zeichenfolge überein. Im MULTILINEModus stimmt ^ auch der Zeilenanfang überein, dh nach einem Zeilenabschluss.

Beispielsweise:

Java

String result = input.split("(?m)^");

PHP

$result = preg_split('/^/m', $input);

Beachten Sie, dass sich vor dem Eintrag ein zusätzlicher leerer String befindet. Entfernen Sie ihn einfach oder entfernen Sie die Schleife aus Index 1.

Erläuterung

Auf den ersten Blick scheint dies eine gute Antwort mit einer (etwas) funktionierenden Lösung zu sein, verbunden mit einer Erläuterung mit einigen Empfehlungen zur Codierung von Best Practices. Die Lösung selbst ist jedoch ein Troll ( "Ich weiß, ich werde reguläre Ausdrücke verwenden." Jetzt haben sie zwei Probleme. ), Und der gesamte Beitrag ist mit subtil falschen Informationen übersät, die jeden Neuling in die Programmierung einflößen werden.

• Verschiedene Regex-Engines unterstützen verschiedene Funktionen. Wenn die Zielmaschine nicht über die Funktion verfügt, die Sie in Ihrem regulären Ausdruck verwenden, ist das Portieren des Codes nicht so einfach wie das Kopieren und Einfügen. Es ist möglicherweise möglich, mit unterstützten Funktionen zu simulieren, oder es ist möglicherweise überhaupt nicht möglich, dies nur mit regulären Ausdrücken zu tun.
• Es gibt zwei Arten von Engines : Textgesteuerte Engine (automatisiert) und Regex-gesteuerte Engine (Backtracking). Ersterer gibt die am weitesten links liegende längste Zeichenfolge zurück, letzterer die am weitesten links liegende voreingenommene Zeichenfolge (voreingenommen in Richtung der vom regulären Ausdruck angegebenen Erkundungsreihenfolge). Der gleiche Ausdruck kann bei den beiden Motortypen zu unterschiedlichen Ergebnissen führen.
• Selbst für dasselbe Feature kann eine andere Regex-Engine eine andere Syntax haben, um sie anzugeben.
• Sogar für dasselbe Feature und dieselbe Syntax können verschiedene Regex-Engines ein unterschiedliches Verhalten beim Parsen und Abgleichen aufweisen. Abgesehen von Fehlern kann der Unterschied vom Design der Regex-Engine herrühren (möglicherweise oder möglicherweise nicht dokumentiert).
• Im MULTILINEModus ist das Verhalten von ^und $abhängig von der Definition von "Leitungsabschluss". Java hält \r\n, \n, \r, \u0085, \u2028, \u2029Leitungsabschluss zu sein, wo \r\nSequenz Atom betrachtet wird. JavaScript hält \n, \r, \u2028, \u2029Linie Terminatoren zu sein. Ruby betrachtet nur \nals Zeilenabschluss.
• splitFunktion kann unterschiedliche Semantik in verschiedenen Sprachen für Eckfälle haben. Python teilt nicht bei leeren Übereinstimmungen auf, Java entfernt nachgestellte leere Zeichenfolgen (es sei denn, Sie geben ein negatives Limit an), JavaScript teilt nicht bei einer leeren Zeichenfolgenübereinstimmung bei Index 0 auf.
• Die "schlechte Lösung" ist tatsächlich portabler als die "empfohlene Lösung". Was als Zeilenendezeichen zu betrachten ist, hängt jedoch von der Spezifikation Ihrer Arbeit ab (z. B. C-Quellcode).
• Derzeit entsprechen die meisten Regex-Engines nicht einmal der Unicode-Unterstützung der Stufe 1 . Sie können Unicode-Eigenschaften und -Blöcke haben, aber die Implementierung für den Abschnitt "Liniengrenze" ist überall, wie oben erläutert. JavaScript unterstützt nicht einmal Unicode-Zeicheneigenschaften!

Bash-Skript

new_string=`echo $string`

Dies teilt die Zeichenfolge durch Zeilenumbrüche. Wenn Sie das Echo $new_string, werden Sie feststellen, dass es neue Zeile in Array-Trennzeichen ersetzt.

Beispielausgabe:

[glitchmr@guava ~]$ string=$'some\nnice\nstring'
[glitchmr@guava ~]$ echo "$string"
some
nice
string
[glitchmr@guava ~]$ new_string=`echo $string`
[glitchmr@guava ~]$ echo "$new_string"
some nice string
[glitchmr@guava ~]$

Java

Dies liest nicht aus einer Datei. Reguläre Ausdrücke werden verwendet. Der Code geht davon aus, dass die gelesene Zeichenfolge das Zeichen '\ n' enthält, um die neue Zeile anzugeben. Die Zahlen 1,2,3,4 geben die Aufteilung an.

public static void main(String args[])
{

    String strSource = "1.This is a string.This is a string.This is a string.This is a string.This is a string.\n2.This is a string.This is a string.This is a string.This is a string.This is a string.\n3.This is a string.This is a string.This is a string.This is a string.This is a string.\n4.This is a string.This is a string.This is a string.This is a string.This is a string.";
    String[] tokens = Pattern.compile("\n").split(strSource,10) ;
    for (int loop=0;loop<tokens.length;loop++)
        System.out.println(tokens[loop]);
}

C #

static class Module1{
    public static void Main()
{
        dynamic i = 0;
        foreach (object line_loopVariable in split_into_lines(Console.In.ReadToEnd())) {
            line = line_loopVariable;
            i += 1;
            Console.WriteLine("Line {0}: {1}", i, line);
        }
    }
    public static IEnumerable<string> split_into_lines(string text){
        dynamic temp_file_name = System.IO.Path.GetTempFileName();
        System.IO.File.WriteAllText(temp_file_name, text);
        return System.IO.File.ReadLines(temp_file_name);
    }
}

Sie geben nicht an, ob bei der "neuen Zeile", in die Sie Ihre Zeichenfolge aufteilen möchten, zwischen Groß- und Kleinschreibung unterschieden wird. Ich nehme an, unempfindlich.

public class SplitStringAtNewline
{
  public static final String STRING_TO_SPLIT = "Hellonew lineWorld";
  public static void main (String [] args)
  {
     System.out.println (
        String.join("",
          Pattern.compile("[nN][eE][wW] [lL][iI][nN][eE]")
              .splitAsStream(STRING_TO_SPLIT)
              .map((s) -> s + "\n")
              .collect(() -> new ArrayList<>(),
                    (c, e) -> c.add(e), (c1, c2) -> c1.addAll(c2))));

  }
}

Alter, das ist in Powershell ganz einfach.

Holen Sie sich einfach Ihre Zeichenfolge wie folgt:

$string = "Helloworld!"

Dann schleife über zufällige ASCII, bis du deinen String in zwei Teile geteilt hast:

Do {
        1..($string.length+1) | % {$new_string+=[char](random (33..127))}
        rv new_string
} Until ($new_string -eq ($string.insert(($string.length/2)-1," ")))

Schließlich sollten Sie den geteilten String erhalten, den Sie wie folgt ausgeben können:

Write-Host $new_string

Ausgabe:

Hallo Welt!

Php

<? Spliter($yourstring); ?>

Hier ist, wie Sie die Saite teilen. War das nicht einfach?

Jetzt müssen Sie nur noch die Funktion schreiben Spliter()

bash spezifisch

Es ist ein toller Job für die Bash !

Ja, das Aufteilen eines Strings könnte auf ganz einfache Weise erfolgen:

string=$'foo\nbar\nbaz'

Zuerst müssen Sie eine Variable initialisieren, mit der Sie Ihr geteiltes Ergebnis speichern:

declare -a lines

Da nun jede Zeile durch zwei Trennzeichen (Anfang oder Ende der Zeichenfolge) begrenzt ist, benötigen Sie eine Variable, um die erste zu speichern

limitA=0

Ok, jetzt können Sie nach Trennzeichen suchen und Ihre Zeilen mit einer Schleife speichern . Da bash nicht mit Binärwerten arbeiten konnte, können Sie ein Tool wie das folgende verwenden od, um mit Hexadezimalwerten zu arbeiten:

while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

Jetzt haben wir eine geteilte Zeichenfolge in Variable gespeichert lines:

set | grep ^lines=
lines=([0]="foo" [1]="bar" [2]="baz")

Das können wir drucken mit:

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo ${lines[idx]}
done

Alles in einem Skript zusammenfassen:

#!/bin/bash

string=$'this is a very long string containing spaces\nshorted, but containing comas...\nthird line.'
declare -a lines
limitA=0
while read hexline
do
    addr=${hexline%% *}
    hexline="${hexline#$addr}"
    addr=$((16#$addr))
    for field in $hexline
    do
        if [ "$field" = "0a" ]
        then
            lines+=( "${string:limitA:addr-limitA}" )
            limitA=$(( addr + 1 ))
        fi
        ((addr++))
    done
done < <(od -A x -t x1 <<<"$string")

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo $idx: ${lines[idx]}
done

Dies wird drucken:

0: this is a very long string containing spaces
1: shorted, but containing comas...
2: third line.

Moderne Bash

Mit der modernen Bash- Implementierung können Sie Steuerzeichen wie Newline in Variablen speichern und sogar testen:

#!/bin/bash

string=$'foo\nbar\nbaz'
declare -a lines
limitA=0
for (( idx=0 ; idx < ${#string} ; idx++ ))
do

    if [ "${string:idx:1}" = $'\n' ]
    then

        lines+=( "${string:limitA:idx-limitA}" )
        limitA=$(( idx + 1 ))
    fi
done
lines+=( "${string:limitA}" )

for (( idx=0 ; idx < ${#lines[@]} ; idx++ ))
do
    echo ${lines[idx]}
done

Bash Golf

Wenn Sie sich jedoch nicht für die Lesbarkeit interessieren, können Sie ein komprimiertes Skript wie das folgende schreiben:

IFS=$'\n' read -d'' -a lines <<<$'foo\nbar\nbaz'

Das Golf-Skript kann wie folgt aussehen:

#!/bin/bash

IFS=$'\n' read -d'' -a lines <<<$'foo\nbar\nbaz'
printf "%s\n" ${lines[@]}

und geben den gleichen Effekt: Die erste Zeile teilt die Zeichenfolge und speichert sie in einem Array mit dem Namen lines . Die zweite Zeile gibt jedes Mitglied des Arrays " lines " aus, gefolgt von einer neuen Zeile .

Bash + VT-Konsole

Da jedoch viele Benutzer eine auf dem ANSI-VT-Standard basierende Textkonsole verwenden , können Sie das VT-Verhalten Ihrer Konsole verwenden und dies erneut kürzer schreiben:

#!/bin/bash

echo $'foo\nbar\nbaz'

wird das gleiche Ergebnis geben.