From 95cfeaa6066af582bb4924cb5f4ec89a1b04b539 Mon Sep 17 00:00:00 2001 From: Chris Boesch Date: Sat, 23 Mar 2024 15:57:33 +0000 Subject: Update exercises/105_threading2.zig Fixed typo. --- exercises/105_threading2.zig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'exercises') diff --git a/exercises/105_threading2.zig b/exercises/105_threading2.zig index a211551..1330999 100644 --- a/exercises/105_threading2.zig +++ b/exercises/105_threading2.zig @@ -1,5 +1,5 @@ // -// Now that we are familiar with the principles of multithreading, we +// Now that we are familiar with the principles of multi threading, we // boldly venture into a practical example from mathematics. // We will determine the circle number PI with sufficient accuracy. // -- cgit v1.2.3 From ec6f6c5870014eca466c189e4cdd0d6ba040701d Mon Sep 17 00:00:00 2001 From: Dizzyi Date: Mon, 25 Mar 2024 01:11:33 +0800 Subject: added exercise/106_files.zig --- exercises/106_files.zig | 93 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) create mode 100644 exercises/106_files.zig (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig new file mode 100644 index 0000000..450ff96 --- /dev/null +++ b/exercises/106_files.zig @@ -0,0 +1,93 @@ +// +// Until now, we've only been printing our output in the console, +// which is good enough for fighting alien and hermit bookkeeping. +// +// However, many other task require some interaction with the file system, +// which is the underlying structure for organizing files on your computer. +// +// The File System provide a hierarchical structure for storing files +// by organizing files into directories, which hold files and other directories, +// thus creating a tree structure for navigating. +// +// Fortunately, zig standard library provide a simple api for interacting +// with the file system, see the detail documentation here +// +// https://ziglang.org/documentation/master/std/#std.fs +// +// In this exercise, we'll try to +// - create a new directory +// - open a file in the directory +// - write to the file. +// +// import std as always +const std = @import("std"); + +pub fn main() !void { + // first we get the current working directory + const cwd: std.fs.Dir = std.fs.cwd(); + + // then we'll try to make a new directory /output/ + // to put our output files. + cwd.makeDir("output") catch |e| switch (e) { + // there are chance you might want to run this + // program more than once and the path might already + // been created, so we'll have to handle this error + // by doing nothing + // + // we want to catch error.PathAlreadyExists and do nothing + ??? => { + ??? + }, + // if is any other unexpected error we just propagate it through + else => return e, + }; + + // then we'll try to open our freshly created directory + // wait a minute + // opening a directory might fail! + // what should we do here? + const output_dir: std.fs.Dir = cwd.openDir("output", .{}); + + // we try to open the file `zigling.txt`, + // and propagate the error up if there are any errors + const file: std.fs.File = try output_dir.createFile("zigling.txt", .{}); + // it is a good habit to close a file after you are done with + // so that other program can read it and prevent data corruption + // but here we are not yet done writing to the file + // if only there are a keyword in zig that + // allow you "defer" code execute to the end of scope... + file.close(); + + // !you are not allow to switch this two lines to before file closing line! + const byte_written = try file.write("It's zigling time!"); + std.debug.print("succefully wrote {} bytes.\n", .{byte_written}); +} +// to check if you actually write to the file, you can either, +// 1. open the file on your text editor, or +// 2. print the content of the file in the console with command +// >> cat ./output/zigling.txt +// +// +// More on Creating files +// +// notice in: +// ... try output_dir.createFile("zigling.txt", .{}); +// ^^^ +// we passed this anonymous struct to the function call +// +// this is the struct `CreateFlag` with default fields +// { +// read: bool = false, +// truncate: bool = true, +// exclusive: bool = false, +// lock: Lock = .none, +// lock_nonblocking: bool = false, +// mode: Mode = default_mode +// } +// +// Question: +// - what should you do if you want to also read the file after opening it? +// - go to documentation of the struct `std.fs.Dir` here +// https://ziglang.org/documentation/master/std/#std.fs.Dir +// - can you find a function for opening a file? how about deleting a file? +// - what kind of option can you uses with those function? -- cgit v1.2.3 From 23b11a7509915b8c02b9329a78f2df22fe2eac5f Mon Sep 17 00:00:00 2001 From: Alan CHUNG Date: Mon, 25 Mar 2024 16:36:15 +0800 Subject: 106_files.zig format --- exercises/106_files.zig | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig index 450ff96..ffa0f86 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -8,13 +8,13 @@ // The File System provide a hierarchical structure for storing files // by organizing files into directories, which hold files and other directories, // thus creating a tree structure for navigating. -// +// // Fortunately, zig standard library provide a simple api for interacting // with the file system, see the detail documentation here // // https://ziglang.org/documentation/master/std/#std.fs // -// In this exercise, we'll try to +// In this exercise, we'll try to // - create a new directory // - open a file in the directory // - write to the file. @@ -67,14 +67,14 @@ pub fn main() !void { // 2. print the content of the file in the console with command // >> cat ./output/zigling.txt // -// +// // More on Creating files -// +// // notice in: // ... try output_dir.createFile("zigling.txt", .{}); // ^^^ // we passed this anonymous struct to the function call -// +// // this is the struct `CreateFlag` with default fields // { // read: bool = false, @@ -84,7 +84,7 @@ pub fn main() !void { // lock_nonblocking: bool = false, // mode: Mode = default_mode // } -// +// // Question: // - what should you do if you want to also read the file after opening it? // - go to documentation of the struct `std.fs.Dir` here -- cgit v1.2.3 From 74a6e60e17d8e71f9df37e3ac6ae30b4718e6034 Mon Sep 17 00:00:00 2001 From: Alan CHUNG Date: Mon, 25 Mar 2024 16:39:45 +0800 Subject: add patch files for 106_files.zig --- exercises/106_files.zig | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig index ffa0f86..0b593ed 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -35,8 +35,8 @@ pub fn main() !void { // by doing nothing // // we want to catch error.PathAlreadyExists and do nothing - ??? => { - ??? + error.PathAlreadyExists => { + return; }, // if is any other unexpected error we just propagate it through else => return e, @@ -46,7 +46,7 @@ pub fn main() !void { // wait a minute // opening a directory might fail! // what should we do here? - const output_dir: std.fs.Dir = cwd.openDir("output", .{}); + const output_dir: std.fs.Dir = try cwd.openDir("output", .{}); // we try to open the file `zigling.txt`, // and propagate the error up if there are any errors @@ -56,7 +56,7 @@ pub fn main() !void { // but here we are not yet done writing to the file // if only there are a keyword in zig that // allow you "defer" code execute to the end of scope... - file.close(); + defer file.close(); // !you are not allow to switch this two lines to before file closing line! const byte_written = try file.write("It's zigling time!"); -- cgit v1.2.3 From 9ce889b438622b40423068c0a9e8b98f4bb1ec39 Mon Sep 17 00:00:00 2001 From: Alan CHUNG Date: Tue, 26 Mar 2024 13:51:59 +0800 Subject: 106_files.zig actual test --- exercises/106_files.zig | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig index 0b593ed..b590679 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -35,8 +35,8 @@ pub fn main() !void { // by doing nothing // // we want to catch error.PathAlreadyExists and do nothing - error.PathAlreadyExists => { - return; + ??? => { + ???; }, // if is any other unexpected error we just propagate it through else => return e, @@ -46,7 +46,7 @@ pub fn main() !void { // wait a minute // opening a directory might fail! // what should we do here? - const output_dir: std.fs.Dir = try cwd.openDir("output", .{}); + const output_dir: std.fs.Dir = cwd.openDir("output", .{}); // we try to open the file `zigling.txt`, // and propagate the error up if there are any errors @@ -56,11 +56,11 @@ pub fn main() !void { // but here we are not yet done writing to the file // if only there are a keyword in zig that // allow you "defer" code execute to the end of scope... - defer file.close(); + file.close(); // !you are not allow to switch this two lines to before file closing line! const byte_written = try file.write("It's zigling time!"); - std.debug.print("succefully wrote {} bytes.\n", .{byte_written}); + std.debug.print("Succefully wrote {} bytes.\n", .{byte_written}); } // to check if you actually write to the file, you can either, // 1. open the file on your text editor, or -- cgit v1.2.3 From 223fc79e441dab99297472a0cfe8a4c63e423b4e Mon Sep 17 00:00:00 2001 From: Alan CHUNG Date: Wed, 27 Mar 2024 16:40:24 +0800 Subject: 106 & 107 --- exercises/106_files.zig | 9 ++++----- exercises/107_files2.zig | 52 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 56 insertions(+), 5 deletions(-) create mode 100644 exercises/107_files2.zig (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig index b590679..78e6611 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -35,9 +35,7 @@ pub fn main() !void { // by doing nothing // // we want to catch error.PathAlreadyExists and do nothing - ??? => { - ???; - }, + ??? => {}, // if is any other unexpected error we just propagate it through else => return e, }; @@ -46,7 +44,8 @@ pub fn main() !void { // wait a minute // opening a directory might fail! // what should we do here? - const output_dir: std.fs.Dir = cwd.openDir("output", .{}); + var output_dir: std.fs.Dir = cwd.openDir("output", .{}); + defer output_dir.close(); // we try to open the file `zigling.txt`, // and propagate the error up if there are any errors @@ -60,7 +59,7 @@ pub fn main() !void { // !you are not allow to switch this two lines to before file closing line! const byte_written = try file.write("It's zigling time!"); - std.debug.print("Succefully wrote {} bytes.\n", .{byte_written}); + std.debug.print("Successfully wrote {} bytes.\n", .{byte_written}); } // to check if you actually write to the file, you can either, // 1. open the file on your text editor, or diff --git a/exercises/107_files2.zig b/exercises/107_files2.zig new file mode 100644 index 0000000..18d59ef --- /dev/null +++ b/exercises/107_files2.zig @@ -0,0 +1,52 @@ +// +// Prerequisite : +// - exercise/106_files.zig, or +// - create a file {project_root}/output/zigling.txt +// with content `It's zigling time!`(18 byte total) +// +// Now there no point in writing to a file if we don't read from it am I right? +// let's wrote a program to read the content of the file that we just created. +// +// I am assuming you've created the appropriate files for this to work. +// +// Alright, bud, lean in close here's the game plan. +// - First, we open the {project_root}/output/ directory +// - Secondly, we open file `zigling.txt` in that directory +// - then, we initalize an array of character with all letter 'A', and print it +// - Afte that, we read the content of the file to the array +// - Finally, we print out the read content + +const std = @import("std"); + +pub fn main() !void { + // Get the current working directory + const cwd = std.fs.cwd(); + + // try to open ./output assuming you did your 106_files exercise + var output_dir = try cwd.openDir("output", .{}); + defer output_dir.close(); + + // try to open the file + const file = try output_dir.openFile("zigling.txt", .{}); + defer file.close(); + + // initalize an array of u8 with all letter 'A'. + // we need to pick a size of the array, 64 seems like a good number. + // fix the initalization below + var content = ['A']*64; + // this should print out : `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA` + std.debug.print("{s}\n", .{content}); + + // okay, seem like threat of violence is not the answer in this case + // can you go here to find a way to read the content ? + // https://ziglang.org/documentation/master/std/#std.fs.File + // hint: you might find two answer that are both vaild in this case + const byte_read = zig_read_the_file_or_i_will_fight_you(&content); + + // Woah, too screamy, I know you're excited for zigling time but tone it down a bit + // Can you print only what we read from the file ? + std.debug.print("Successfully Read {} byte: {s}\n", .{ + byte_read, + content, // change this line only + }); +} -- cgit v1.2.3 From 05589f8ba1f7a419712a15e3385bd4f0180fb48c Mon Sep 17 00:00:00 2001 From: Alan CHUNG Date: Wed, 27 Mar 2024 16:53:19 +0800 Subject: added format parameter {d} --- exercises/106_files.zig | 2 +- exercises/107_files2.zig | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'exercises') diff --git a/exercises/106_files.zig b/exercises/106_files.zig index 78e6611..aa58ee0 100644 --- a/exercises/106_files.zig +++ b/exercises/106_files.zig @@ -59,7 +59,7 @@ pub fn main() !void { // !you are not allow to switch this two lines to before file closing line! const byte_written = try file.write("It's zigling time!"); - std.debug.print("Successfully wrote {} bytes.\n", .{byte_written}); + std.debug.print("Successfully wrote {d} bytes.\n", .{byte_written}); } // to check if you actually write to the file, you can either, // 1. open the file on your text editor, or diff --git a/exercises/107_files2.zig b/exercises/107_files2.zig index 18d59ef..dadfdf6 100644 --- a/exercises/107_files2.zig +++ b/exercises/107_files2.zig @@ -45,7 +45,7 @@ pub fn main() !void { // Woah, too screamy, I know you're excited for zigling time but tone it down a bit // Can you print only what we read from the file ? - std.debug.print("Successfully Read {} byte: {s}\n", .{ + std.debug.print("Successfully Read {d} byte: {s}\n", .{ byte_read, content, // change this line only }); -- cgit v1.2.3