어떻게 스칼라에서 파일에 쓸?

독서를 들어, 유용한 추상화 소스가있다. 어떻게 텍스트 파일에 줄을 쓸 수 있습니까?

해결법

==============================

1.리 Haoyi 그가 아래에 제시하는 것이, 자신의 라이브러리 lihaoyi / OS-lib 디렉토리 제안이있는 경우 편집 2019 (8 년 이상), 스칼라-IO는 매우 활성화되지 않은 것.

리 Haoyi 그가 아래에 제시하는 것이, 자신의 라이브러리 lihaoyi / OS-lib 디렉토리 제안이있는 경우 편집 2019 (8 년 이상), 스칼라-IO는 매우 활성화되지 않은 것.

년 6 월 2019, 자비에르 Guihot는 그의 대답에 사용하여 라이브러리, 자동 자원 관리를 수행하기위한 유틸리티를 언급하고있다.

편집 (9 월 2011) : 에두아르도 코스타가 Scala2.9에 대해 요청하고 역사를 커밋 scalax.IO 릭-777 주석 이후 2009 년 중반 이후 꽤 많이 존재하기 때문에 ...

스칼라-IO가 변경된 곳이 있습니다 제시 Eichar (도에 SO)에서의 GitHub의의의 repo를 참조하십시오

import scalax.io._

val output:Output = Resource.fromFile("someFile")

// Note: each write will open a new connection to file and 
//       each write is executed at the begining of the file,
//       so in this case the last write will be the contents of the file.
// See Seekable for append and patching files
// Also See openOutput for performing several writes with a single connection

output.writeIntsAsBytes(1,2,3)
output.write("hello")(Codec.UTF8)
output.writeStrings(List("hello","world")," ")(Codec.UTF8)

스칼라-IO에 대한 이전 장소 원래 대답 (2011년 1월) :

당신이 Scala2.9 기다리지 않으려면, 당신은 스칼라 - 인큐베이터 / 스칼라-IO 라이브러리를 사용할 수 있습니다. (에서 언급 한 바와 같이 "왜 스칼라 소스는 기본의 InputStream을 닫습니다하지 않는 이유는 무엇입니까?")

샘플을 참조하십시오

{ // several examples of writing data
    import scalax.io.{
      FileOps, Path, Codec, OpenOption}
    // the codec must be defined either as a parameter of ops methods or as an implicit
    implicit val codec = scalax.io.Codec.UTF8


    val file: FileOps = Path ("file")

    // write bytes
    // By default the file write will replace
    // an existing file with the new data
    file.write (Array (1,2,3) map ( _.toByte))

    // another option for write is openOptions which allows the caller
    // to specify in detail how the write should take place
    // the openOptions parameter takes a collections of OpenOptions objects
    // which are filesystem specific in general but the standard options
    // are defined in the OpenOption object
    // in addition to the definition common collections are also defined
    // WriteAppend for example is a List(Create, Append, Write)
    file.write (List (1,2,3) map (_.toByte))

    // write a string to the file
    file.write("Hello my dear file")

    // with all options (these are the default options explicitely declared)
    file.write("Hello my dear file")(codec = Codec.UTF8)

    // Convert several strings to the file
    // same options apply as for write
    file.writeStrings( "It costs" :: "one" :: "dollar" :: Nil)

    // Now all options
    file.writeStrings("It costs" :: "one" :: "dollar" :: Nil,
                    separator="||\n||")(codec = Codec.UTF8)
  }

==============================
2.이것은 내가 내 개인 라이브러리에 추가하는 것이 매우 유용하다고 표준 스칼라에서 누락 된 기능 중 하나입니다. (당신은 아마 너무, 개인 라이브러리가 있어야합니다.) 코드는과 같이 간다 :

이것은 내가 내 개인 라이브러리에 추가하는 것이 매우 유용하다고 표준 스칼라에서 누락 된 기능 중 하나입니다. (당신은 아마 너무, 개인 라이브러리가 있어야합니다.) 코드는과 같이 간다 :
```
def printToFile(f: java.io.File)(op: java.io.PrintWriter => Unit) {
  val p = new java.io.PrintWriter(f)
  try { op(p) } finally { p.close() }
}
```
그것은 다음과 같이 사용되는 :
```
import java.io._
val data = Array("Five","strings","in","a","file!")
printToFile(new File("example.txt")) { p =>
  data.foreach(p.println)
}
```

==============================

3.렉스 커에 의해 대답 비슷하지만 더 일반적인. 우선은 도우미 함수를 사용합니다 :

렉스 커에 의해 대답 비슷하지만 더 일반적인. 우선은 도우미 함수를 사용합니다 :

/**
 * Used for reading/writing to database, files, etc.
 * Code From the book "Beginning Scala"
 * http://www.amazon.com/Beginning-Scala-David-Pollak/dp/1430219890
 */
def using[A <: {def close(): Unit}, B](param: A)(f: A => B): B =
try { f(param) } finally { param.close() }

그럼이로 사용 :

def writeToFile(fileName:String, data:String) = 
  using (new FileWriter(fileName)) {
    fileWriter => fileWriter.write(data)
  }

과

def appendToFile(fileName:String, textData:String) =
  using (new FileWriter(fileName, true)){ 
    fileWriter => using (new PrintWriter(fileWriter)) {
      printWriter => printWriter.println(textData)
    }
  }

기타

==============================

4.간단한 대답 :

간단한 대답 :

import java.io.File
import java.io.PrintWriter

def writeToFile(p: String, s: String): Unit = {
    val pw = new PrintWriter(new File(p))
    try pw.write(s) finally pw.close()
  }

==============================
5.다른 답변의 내 편집 어디 거부하기 때문에, 다른 대답을주기.

다른 답변의 내 편집 어디 거부하기 때문에, 다른 대답을주기.

이것은 (가렛 홀의 유사) 가장 간결하고 간단한 대답이다
```
File("filename").writeAll("hello world")
```
이 Jus12 비슷하지만 상세없이 올바른 코드 스타일
```
def using[A <: {def close(): Unit}, B](resource: A)(f: A => B): B =
  try f(resource) finally resource.close()

def writeToFile(path: String, data: String): Unit = 
  using(new FileWriter(path))(_.write(data))

def appendToFile(path: String, data: String): Unit =
  using(new PrintWriter(new FileWriter(path, true)))(_.println(data))
```
당신도 람다, 마지막 시도에 대한 중괄호를해야하고, 자리 구문의 사용을주의하지 마십시오. 또한 더 나은 이름을 확인합니다.
==============================
6./ 저장 문자열에서 /로 읽기, java.nio의 사용을위한 하나 라이너.

/ 저장 문자열에서 /로 읽기, java.nio의 사용을위한 하나 라이너.
```
import java.nio.file.{Paths, Files, StandardOpenOption}
import java.nio.charset.{StandardCharsets}
import scala.collection.JavaConverters._

def write(filePath:String, contents:String) = {
  Files.write(Paths.get(filePath), contents.getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE)
}

def read(filePath:String):String = {
  Files.readAllLines(Paths.get(filePath), StandardCharsets.UTF_8).asScala.mkString
}
```
이것은 큰 파일에 적합하지 않습니다,하지만 일을 할 것입니다.

일부 링크 :

java.nio.file.Files.write java.lang.String.getBytes scala.collection.JavaConverters scala.collection.immutable.List.mkString
==============================
7.여기서 스칼라 컴파일러 라이브러리를 사용 간결한 한 라이너는 :

여기서 스칼라 컴파일러 라이브러리를 사용 간결한 한 라이너는 :
```
scala.tools.nsc.io.File("filename").writeAll("hello world")
```
당신은 자바 라이브러리를 사용하려는 경우 또는이 해킹을 수행 할 수 있습니다 :
```
Some(new PrintWriter("filename")).foreach{p => p.write("hello world"); p.close}
```
==============================
8.마이크로 라이브러리가 내가 쓴 : https://github.com/pathikrit/better-files

마이크로 라이브러리가 내가 쓴 : https://github.com/pathikrit/better-files
```
file.appendLine("Hello", "World")
```
또는
```
file << "Hello" << "\n" << "World"
```
==============================
9.불행하게도 상단 대답 스칼라-IO는 죽었어요. 타사 종속성을 사용하여 괜찮다면 내 OS-lib 디렉토리의 라이브러리를 사용하는 것이 좋습니다. 이것은 매우 쉽게 파일, 경로 및 파일 시스템 작업을합니다 :

불행하게도 상단 대답 스칼라-IO는 죽었어요. 타사 종속성을 사용하여 괜찮다면 내 OS-lib 디렉토리의 라이브러리를 사용하는 것이 좋습니다. 이것은 매우 쉽게 파일, 경로 및 파일 시스템 작업을합니다 :
```
// Make sure working directory exists and is empty
val wd = os.pwd/"out"/"splash"
os.remove.all(wd)
os.makeDir.all(wd)

// Read/write files
os.write(wd/"file.txt", "hello")
os.read(wd/"file.txt") ==> "hello"

// Perform filesystem operations
os.copy(wd/"file.txt", wd/"copied.txt")
os.list(wd) ==> Seq(wd/"copied.txt", wd/"file.txt")
```
이 파일을 파일에 기록하는 파일을 추가, 덮어 쓰기위한 하나의 라이너, 그리고 다른 많은 유용한 / 일반적인 작업이 있습니다
==============================
10.스칼라 2.13부터, 표준 라이브러리는 전용 자원 관리 유틸리티를 제공합니다 : 사용.

스칼라 2.13부터, 표준 라이브러리는 전용 자원 관리 유틸리티를 제공합니다 : 사용.

파일에 기록하지 않고, 무슨 일이 있어도 나중에 리소스를 종료하기 위해 AutoCloseable 확장 등의 PrintWriter 또는 BufferedWriter의 같은 자원이 경우에 사용할 수 있습니다 :

==============================

11.2019 / 9월 / 01에 업데이트 :

2019 / 9월 / 01에 업데이트 :

쉽게 스칼라에서 파일을 작성하고, 그들 중 일부는 아주 좋네요하는 방법에 대한 이러한 모든 답변을 검토 한 결과, 세 가지 문제가 있었다 :

시작하기 전에, 내 목표는 간결하지 않습니다. 그것은 스칼라 / FP 초보자, 자바에서 오는 일반적으로 사람들에게 쉽게 이해를 용이하게합니다. 맨 마지막에서, 나는 함께 모든 비트를 당긴 다음 간결함을 증가시킬 것이다.

첫째, 사용 방법은 시도를 사용하도록 업데이트해야합니다 (다시, 간결 여기에 목표 아니다). 그것은 tryUsingAutoCloseable로 이름이 변경됩니다

def tryUsingAutoCloseable[A <: AutoCloseable, R]
  (instantiateAutoCloseable: () => A) //parameter list 1
  (transfer: A => scala.util.Try[R])  //parameter list 2
: scala.util.Try[R] =
  Try(instantiateAutoCloseable())
    .flatMap(
      autoCloseable => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(autoCloseable)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            autoCloseable.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

대신 습관 하나의 매개 변수 목록의 두 매개 변수 목록을 가지고 나타나기 때문에 위의 tryUsingAutoCloseable 방법의 시작은 혼란 스러울 수 있습니다. 이것은 태닝이라고합니다. 또는 가끔 유용 곳에 작품을 무두질하는 방법 그리고 세부 사항으로 가지 않을 것이다. 그것은이 특정 문제 공간에 대해,이 작업에 적합한 도구입니다 것으로 나타났다.

다음으로, 우리는 생성 (또는 기존 덮어 쓰기) 파일과 목록 [문자열]을 쓸 것입니다 방법, tryPrintToFile를 작성해야합니다. 그것은의 PrintWriter에 의해 캡슐화 차례에 BufferedWriter의에 의해 캡슐화 된 FileWriter를 사용합니다. 그리고 성능을 상승시킬 수의 BufferedWriter의 기본보다 훨씬 큰 기본 버퍼 크기는 defaultBufferSize을 정의하고, 값 65536을 할당됩니다.

여기에 코드입니다 (다시, 간결 여기에 목표되지 않습니다)

val defaultBufferSize: Int = 65536

def tryPrintToFile(
  lines: List[String],
  location: java.io.File,
  bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
  tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
    fileWriter =>
      tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
        bufferedWriter =>
          tryUsingAutoCloseable(() => new java.io.PrintWriter(bufferedWriter)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
            printWriter =>
              scala.util.Try(
                lines.foreach(line => printWriter.println(line))
              )
          }
      }
  }
}

이 입력으로리스트 [문자열] 가져와 파일로 전송한다는 점에서 전술 tryPrintToFile 방법은 유용하다. 의 지금 문자열을 받아 파일에 기록하는 tryWriteToFile 방법을 만들어 보자.

여기에 코드 (그리고 난 당신이 여기에 간결의 우선 순위를 추측 할 수 있습니다)

def tryWriteToFile(
  content: String,
  location: java.io.File,
  bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
  tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
    fileWriter =>
      tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
        bufferedWriter =>
          Try(bufferedWriter.write(content))
      }
  }
}

마지막으로, 문자열로 파일의 내용을 가져올 수있는 것이 유용하다. scala.io.Source 쉽게 파일의 내용을 얻기위한 편리한 방법을 제공하지만, close 메소드는 기본 JVM을 해제하기 위해 자료를 사용할 수 있어야하며 파일 시스템 처리합니다. 이 작업이 완료되지 않은 경우, 자원은 JVM GC (가비지 콜렉터) 소스 인스턴스 자체를 해제 주위 때까지 해제되지 않습니다. 그리고 그렇다하더라도, finalize 메소드는 자원을 닫습니다 GC에 의해 호출에만 약한 JVM 보증이있다. 이것은 java.lang.AutoCloseable의 인스턴스에 키가 가까운 클라이언트의 책임이 명시 적으로 똑같이, close 메소드를 호출하는 클라이언트의 책임이 있음을 의미합니다. 이를 위해 scala.io.Source를 처리하는 사용 방법의 제 2 정의가 필요하다.

다음은이에 대한 코드는 (여전히 간결되지 않는)입니다 :

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)
  (transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(source)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            source.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

그리고 여기에 슈퍼 간단한 라인 스트리밍 파일 리더 (현재 데이터베이스 출력에서 탭으로 구분 된 파일을 읽을 사용)에서의 사용 예는 다음과 같습니다

def tryProcessSource(
    file: java.io.File
  , parseLine: (String, Int) => List[String] = (line, index) => List(line)
  , filterLine: (List[String], Int) => Boolean = (values, index) => true
  , retainValues: (List[String], Int) => List[String] = (values, index) => values
  , isFirstLineNotHeader: Boolean = false
): scala.util.Try[List[List[String]]] =
  tryUsingSource(scala.io.Source.fromFile(file)) {
    source =>
      scala.util.Try(
        ( for {
            (line, index) <-
              source.getLines().buffered.zipWithIndex
            values =
              parseLine(line, index)
            if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
            retainedValues =
              retainValues(values, index)
          } yield retainedValues
        ).toList //must explicitly use toList due to the source.close which will
                 //occur immediately following execution of this anonymous function
      )
  )

위의 함수의 업데이트 된 버전은 다르지만 관련 StackOverflow의 질문에 대한 답변으로 제공하고있다.

이제, (쉽게 더 쉽게 텍스트 편집기를 사용하여 검사 할 바탕 화면에 출력을 덤프 할 수 있도록 이클립스 ScalaIDE와 IntelliJ를 스칼라 플러그인 모두 스칼라 워크 시트 존재로 붙여 넣기가 훨씬 더 쉽게) 추출 수입과 모든 것을 함께 가져, 이 코드가 (증가 간결함과) 모습입니다 :

import scala.io.Source
import scala.util.Try
import java.io.{BufferedWriter, FileWriter, File, PrintWriter}

val defaultBufferSize: Int = 65536

def tryUsingAutoCloseable[A <: AutoCloseable, R]
  (instantiateAutoCloseable: () => A) //parameter list 1
  (transfer: A => scala.util.Try[R])  //parameter list 2
: scala.util.Try[R] =
  Try(instantiateAutoCloseable())
    .flatMap(
      autoCloseable => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(autoCloseable)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            autoCloseable.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

def tryUsingSource[S <: scala.io.Source, R]
  (instantiateSource: () => S)
  (transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
  Try(instantiateSource())
    .flatMap(
      source => {
        var optionExceptionTry: Option[Exception] = None
        try
          transfer(source)
        catch {
          case exceptionTry: Exception =>
            optionExceptionTry = Some(exceptionTry)
            throw exceptionTry
        }
        finally
          try
            source.close()
          catch {
            case exceptionFinally: Exception =>
              optionExceptionTry match {
                case Some(exceptionTry) =>
                  exceptionTry.addSuppressed(exceptionFinally)
                case None =>
                  throw exceptionFinally
              }
          }
      }
    )

def tryPrintToFile(
  lines: List[String],
  location: File,
  bufferSize: Int = defaultBufferSize
): Try[Unit] =
  tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
    tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
      tryUsingAutoCloseable(() => new PrintWriter(bufferedWriter)) { printWriter =>
          Try(lines.foreach(line => printWriter.println(line)))
      }
    }
  }

def tryWriteToFile(
  content: String,
  location: File,
  bufferSize: Int = defaultBufferSize
): Try[Unit] =
  tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
    tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
      Try(bufferedWriter.write(content))
    }
  }

def tryProcessSource(
    file: File,
  parseLine: (String, Int) => List[String] = (line, index) => List(line),
  filterLine: (List[String], Int) => Boolean = (values, index) => true,
  retainValues: (List[String], Int) => List[String] = (values, index) => values,
  isFirstLineNotHeader: Boolean = false
): Try[List[List[String]]] =
  tryUsingSource(() => Source.fromFile(file)) { source =>
    Try(
      ( for {
          (line, index) <- source.getLines().buffered.zipWithIndex
          values = parseLine(line, index)
          if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
          retainedValues = retainValues(values, index)
        } yield retainedValues
      ).toList
    )
  }

스칼라 / FP 초보자로서, 나는 위의 지식과 솔루션을 수입 (주로 머리를 긁적 좌절에) 많은 시간을 점화했습니다. 나는이 다른 스칼라 / FP 초보자이 특정 학습 혹 빨리 극복하는 데 도움이되기를 바랍니다.

==============================

12.여기 scalaz 스트림을 사용하여 파일에 몇 줄을 쓰기의 예입니다.

여기 scalaz 스트림을 사용하여 파일에 몇 줄을 쓰기의 예입니다.

import scalaz._
import scalaz.stream._

def writeLinesToFile(lines: Seq[String], file: String): Task[Unit] =
  Process(lines: _*)              // Process that enumerates the lines
    .flatMap(Process(_, "\n"))    // Add a newline after each line
    .pipe(text.utf8Encode)        // Encode as UTF-8
    .to(io.fileChunkW(fileName))  // Buffered write to the file
    .runLog[Task, Unit]           // Get this computation as a Task
    .map(_ => ())                 // Discard the result

writeLinesToFile(Seq("one", "two"), "file.txt").run

==============================

13.samthebest 그 전에 기여를 능가하기 위해, 나는 이름과 간결함을 향상 :

samthebest 그 전에 기여를 능가하기 위해, 나는 이름과 간결함을 향상 :

  def using[A <: {def close() : Unit}, B](resource: A)(f: A => B): B =
    try f(resource) finally resource.close()

  def writeStringToFile(file: File, data: String, appending: Boolean = false) =
    using(new FileWriter(file, appending))(_.write(data))

==============================

14.

def write(destinationFile: Path, fileContent: String): Either[Exception, Path] =
  write(destinationFile, fileContent.getBytes(StandardCharsets.UTF_8))

def write(destinationFile: Path, fileContent: Array[Byte]): Either[Exception, Path] =
  try {
    Files.createDirectories(destinationFile.getParent)
    // Return the path to the destinationFile if the write is successful
    Right(Files.write(destinationFile, fileContent))
  } catch {
    case exception: Exception => Left(exception)
  }

val filePath = Paths.get("./testDir/file.txt")

write(filePath , "A test") match {
  case Right(pathToWrittenFile) => println(s"Successfully wrote to $pathToWrittenFile")
  case Left(exception) => println(s"Could not write to $filePath. Exception: $exception")
}

==============================
15.당신은 어쨌든 프로젝트에 Akka 스트림가 발생하는 경우, 그것은 한 줄을 제공합니다 :

당신은 어쨌든 프로젝트에 Akka 스트림가 발생하는 경우, 그것은 한 줄을 제공합니다 :
```
def writeToFile(p: Path, s: String)(implicit mat: Materializer): Unit = {
  Source.single(ByteString(s)).runWith(FileIO.toPath(p))
}
```
Akka 문서> 스트리밍 파일 IO

==============================

16.2019 업데이트 :

2019 업데이트 :

요약 - 자바 NIO (또는 비동기에 대한 NIO.2)는 여전히 스칼라에서 지원하는 가장 포괄적 인 파일 처리 솔루션입니다. 다음 코드는 생성하고 새 파일에 텍스트를 작성합니다 :

import java.io.{BufferedOutputStream, OutputStream}
import java.nio.file.{Files, Paths}

val testFile1 = Paths.get("yourNewFile.txt")
val s1 = "text to insert in file".getBytes()

val out1: OutputStream = new BufferedOutputStream(
  Files.newOutputStream(testFile1))

try {
  out1.write(s1, 0, s1.length)
} catch {
  case _ => println("Exception thrown during file writing")
} finally {
  out1.close()
}

==============================

17.이 답변과 마찬가지로, 여기 FS2 (버전 1.0.4)과 예입니다 :

이 답변과 마찬가지로, 여기 FS2 (버전 1.0.4)과 예입니다 :

import cats.effect._

import fs2._
import fs2.io

import java.nio.file._

import scala.concurrent.ExecutionContext
import scala.language.higherKinds
import cats.syntax.functor._

object ScalaApp extends IOApp {

  def write[T[_]](p: Path, s: String)
                 (implicit F: ConcurrentEffect[T], cs: ContextShift[T]): T[Unit] = {
    Stream(s)
      .covary[T]
      .through(text.utf8Encode)
      .through(
        io.file.writeAll(
          p,
          scala.concurrent.ExecutionContext.global,
          Seq(StandardOpenOption.CREATE)
        )
      )
      .compile
      .drain
  }


  def run(args: List[String]): IO[ExitCode] = {

    implicit val executionContext: ExecutionContext =
      scala.concurrent.ExecutionContext.Implicits.global

    implicit val contextShift: ContextShift[IO] =
      IO.contextShift(executionContext)

    val outputFile: Path = Paths.get("output.txt")

    write[IO](outputFile, "Hello world\n").as(ExitCode.Success)

  }
}

==============================
18.이 줄은 배열 또는 문자열에서 파일을 작성하는 데 도움이됩니다.

이 줄은 배열 또는 문자열에서 파일을 작성하는 데 도움이됩니다.
```
 new PrintWriter(outputPath) { write(ArrayName.mkString("")); close }
```

from https://stackoverflow.com/questions/4604237/how-to-write-to-a-file-in-scala by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] 어떻게 DataFrame의 파티션을 정의? (0)	2019.10.29
[SCALA] 스칼라 형 람다는 무엇인가 자신의 장점은 무엇입니까? (0)	2019.10.29
[SCALA] 불꽃 제출 - 스파크 작업에 항아리를 추가 (0)	2019.10.29
[SCALA] JVM은 꼬리 호출 최적화를 방지합니까? (0)	2019.10.29
[SCALA] 당신이 등 괄호, 점, 중괄호, = (기능)을 생략 할 수있는 경우에 대한 정확한 규칙은 무엇입니까? (0)	2019.10.29

복붙노트

[SCALA] 어떻게 스칼라에서 파일에 쓸?

어떻게 스칼라에서 파일에 쓸?

해결법

1.리 Haoyi 그가 아래에 제시하는 것이, 자신의 라이브러리 lihaoyi / OS-lib 디렉토리 제안이있는 경우 편집 2019 (8 년 이상), 스칼라-IO는 매우 활성화되지 않은 것.

2.이것은 내가 내 개인 라이브러리에 추가하는 것이 매우 유용하다고 표준 스칼라에서 누락 된 기능 중 하나입니다. (당신은 아마 너무, 개인 라이브러리가 있어야합니다.) 코드는과 같이 간다 :

3.렉스 커에 의해 대답 비슷하지만 더 일반적인. 우선은 도우미 함수를 사용합니다 :

4.간단한 대답 :

5.다른 답변의 내 편집 어디 거부하기 때문에, 다른 대답을주기.

6./ 저장 문자열에서 /로 읽기, java.nio의 사용을위한 하나 라이너.

7.여기서 스칼라 컴파일러 라이브러리를 사용 간결한 한 라이너는 :

8.마이크로 라이브러리가 내가 쓴 : https://github.com/pathikrit/better-files

9.불행하게도 상단 대답 스칼라-IO는 죽었어요. 타사 종속성을 사용하여 괜찮다면 내 OS-lib 디렉토리의 라이브러리를 사용하는 것이 좋습니다. 이것은 매우 쉽게 파일, 경로 및 파일 시스템 작업을합니다 :

10.스칼라 2.13부터, 표준 라이브러리는 전용 자원 관리 유틸리티를 제공합니다 : 사용.

11.2019 / 9월 / 01에 업데이트 :

12.여기 scalaz 스트림을 사용하여 파일에 몇 줄을 쓰기의 예입니다.

13.samthebest 그 전에 기여를 능가하기 위해, 나는 이름과 간결함을 향상 :

14.

15.당신은 어쨌든 프로젝트에 Akka 스트림가 발생하는 경우, 그것은 한 줄을 제공합니다 :

16.2019 업데이트 :

17.이 답변과 마찬가지로, 여기 FS2 (버전 1.0.4)과 예입니다 :

18.이 줄은 배열 또는 문자열에서 파일을 작성하는 데 도움이됩니다.

'SCALA' 카테고리의 다른 글

티스토리툴바