YT YouTube2Text

YouTube2Text → Transcripts → String Functions (format, gsub, split, etc.) - Roblox Advanced Scripting #23

String Functions (format, gsub, split, etc.) - Roblox Advanced Scripting #23 — Transcript

by BrawlDev · 4,969 words · 643 segments · language en · Watch on YouTube

Open in transcriber Summarize with AI Download SRT/VTT

Full transcript

0:00oh my God it's a string it's literally a
0:04string on a base plate okay I'm going to
0:06be honest I don't really know where I'm
0:07going with this intro but if you
0:09couldn't guess from the title of this
0:10video this Roblox Advanced scripting
0:12episode is going to cover string
0:14functions from the string library that
0:17Roblox has provided to us that we can
0:19use to read but also modify strings in
0:22Roblox studio and I'm going to be
0:24showing you 10 of the most commonly used
0:26functions from the string library that
0:28Roblox has for us to offer so with that
0:30being said let's go ahead and get
0:31straight into implementing in Roblox
0:33studio now that we understand it let's
0:35Implement string functions inside of
0:36Roblox studio so I quickly whipped up a
0:39script inside of server script service
0:40that has two lines one for a variable
0:43that is set equal to a the string hello
0:45world and then we're simply just going
0:46to print that string now we don't need
0:49to go over what this does it's very
0:50self-explanatory but I do want to
0:53incorporate uh some string functions to
0:56uh our already existing strings so that
0:58I can show you all the different way
0:59ways you can manipulate strings um and
1:02incorporate them in your Roblox game
1:04starting with the first function which
1:06is called Len and this is basically
1:08short for length and this function
1:10basically counts the length of a string
1:13and the length of a string is determined
1:15by the number of characters uh that are
1:18in a specific string so in this case uh
1:21this string hello world it has 1 2 3 4 5
1:246 cuz we're counting the space as a
1:26character 7 8 9 10 11 12 so it should be
1:30a length of 12 characters and that is
1:32essentially what this function should
1:34return if we use the Len function and
1:37this is basically what it's going to
1:38look like so in our print statement
1:40we're simply just going to start by
1:41saying string. Len we start with the
1:45keyword string and then dot Len which is
1:47the function name and then we're going
1:49to wrap our and then we're going to wrap
1:51this in parentheses and put my string as
1:55a argument for it so if we were to go
1:57into the game hit test and then hit run
2:00we should see in the output it should
2:02say the number 12 because instead of
2:04printing out the string itself we are
2:06printing the length of the string which
2:08is going to be 12 so this is one of the
2:10easiest and also most useful string
2:13functions to use in Roblox studio and in
2:15Roblox studio and I highly recommend you
2:17use this in your future games the next
2:20string function is called find and this
2:22function essentially allows us to locate
2:25a specific location within a string uh
2:29to find a specific pattern that we want
2:31to look for so let's say we were looking
2:33at this string hello world and we wanted
2:35to look for just the hello part uh
2:38basically what would happen is if we
2:41used this find function it's going to
2:43return two numbers it's going to return
2:45the index of where it starts to find
2:47this word and then the index of where
2:49this word ends so if you remember how we
2:52count indices in a string we basically
2:54start at index one and then we go up
2:57like we're just counting numbers
2:58basically um so it's going to start at
3:01index one with h and then it's going to
3:04end at index 5 with the O and that is
3:07essentially what string doind allows us
3:09to do so instead of string. Len we're
3:12going to replace this with string. find
3:14and then it's going to take in two
3:17arguments the first one is going to be
3:18the string itself and then the second
3:20argument is going to be the pattern that
3:22we're looking for and if you remember
3:24the pattern is hello which is what we're
3:26trying to look for so if we go into the
3:28game now and hit run what should happen
3:31in the output is it returns back two
3:33numbers like I said it returns back two
3:35numbers the first one being the starting
3:37index of where we start to find this
3:39pattern and then the end location of
3:42this pattern that we are looking for and
3:45we can be more specific about this too
3:47like if we just wanted to look for were
3:49like in world then it's going to give us
3:52the starting and ending index of just
3:55those um characters inside of the string
3:59so it starts at uh index 7 and then ends
4:01at index 9 and so if you really wanted
4:03to you could make two variables like
4:05this by saying local start index comma
4:08end index equals and then we can just
4:11take string. find cut this paste it into
4:14here and then you basically now have two
4:16variables here separately one for the
4:18starting index and one for the ending
4:20index and that is essentially how string
4:22do find works the next function is
4:24called G sub and this is essentially
4:27short for Global substitution so what
4:30this function does is it takes a string
4:32and then we pass in a pattern that we're
4:35looking for so if we were to let's say
4:37look for the word hello if we wanted to
4:40replace this word with a different word
4:42then we're going to go through the
4:43entire string look for this pattern and
4:45then we're going to replace it and then
4:47essentially return back a new string
4:49that has a new string that made the
4:52changes that we were looking for and I'm
4:54going to show you what this looks like
4:56so we're just simply going to say
4:58string. G sub open and close parentheses
5:01and then the first thing we're going to
5:02pass in is the string itself my string
5:05and then we're going to look for a
5:06pattern which let's say instead of world
5:09what if we wanted to change this to
5:10something different like braev or
5:12something then we're going to look for
5:14the pattern which is going to be world
5:16and then we have to pass in this
5:18replacement now this replacement can be
5:20a string it can be a table or it could
5:22even be another function itself but I'm
5:24going to show you all three examples the
5:26first one is just going to be a normal
5:27string so I'm just going to replace this
5:30with brev and so what should happen is
5:32it's going to return the new string
5:34that's modified but it actually returns
5:37two values so the first one is going to
5:41be the new string itself and then the
5:43second one is going to be the number of
5:45occurrences that um or the number of
5:48changes that have happened to the string
5:50because we might find hello world world
5:53like this so it'll just change it twice
5:56instead of once and so that's going to
5:59keep track of how many times it's been
6:00recorded it's going to be in the second
6:02variable so it's we're just going to
6:03call this one uh num occurences
6:07equals and then string. G sub so we can
6:10uh print the new string and we can also
6:13print the number of occurrences like
6:17this so if we go into the game hit run
6:19then what we should see in the output is
6:21first the new string so it's going to
6:23say hello braev brev because there's two
6:27worlds so we changed it both times and
6:29then it returned the number of
6:30occurrences that uh have changed with
6:33the string now if let's say we wanted to
6:35look for any word and not just a
6:38specific word uh like if we wanted to
6:40look for hello world world all that sort
6:43of stuff like as long as it's spaced out
6:45by a space and these are all individual
6:48words that we're trying to look for then
6:50what we can do is use a special pattern
6:52that allows us to capture that so I'm
6:54just going to comment this out I'm going
6:56to copy this paste it down here instead
6:59of of having the pattern just be the
7:01string world what we want to do instead
7:04is make this a um a word identifier and
7:07this is essentially what it's going to
7:08look like we're going to put in a uh
7:11percent symbol W like w stands for word
7:14and then we're going to add a plus sign
7:16indicating that we can have more than
7:18one word that we look for um I'm going
7:20to explain in more detail what this
7:22identifier means but this is essentially
7:24how you capture uh any word inside of a
7:27string and we're going to replace
7:28whatever's inside of here with um this
7:31with whatever the replacement is on the
7:32right so if we hit run then everything
7:35should say braev braev braev uh just
7:38like that so that is how that works now
7:41if we let's say wanted to uh make a
7:44table instead of having a direct
7:45replacement just be a string we can have
7:48a dictionary of tables that tell us that
7:50we want to replace hello with something
7:51else or if we want to replace world with
7:54something else then we can use a table
7:56so I'm going to comment this out and I'm
7:57going to show you down here um that we
8:00can indicate any word that's in here but
8:03we can put a replacement dictionary
8:05inside of here uh like this so for each
8:09key uh it's going to be the word that
8:11we're looking for so in this case we can
8:13say one example being hello we're going
8:15to set this equal to uh the the new
8:20string that we want to replace this with
8:21so that's going to be the value so
8:23instead of hello what if we just wanted
8:24to say uh greetings like this and then
8:27we'll space this out with a comma and
8:29then
8:29we can replace world with uh let's say
8:32braw Dev instead so now anytime we find
8:36a word that matches hello we're going to
8:38replace it with greetings anytime we
8:40find a word that matches World we're
8:42going to replace it with balev so now
8:44let's hit run and then see our new
8:45output so it should say greetings balev
8:49brev and it should have been replaced
8:51three times because we used a uh
8:53dictionary to allow us to change
8:55specific words uh in the string here's
8:58another cool thing we can do
8:59we can put this in a function that
9:01basically says uh whatever word we find
9:04in here then we can put this in a
9:06function and return a new value based on
9:09the outcome of this function that um we
9:11give it I'm going to show you what this
9:12looks like so I'm going to drop a line
9:14down here paste this into here and then
9:17right before it we're going to declare a
9:18new function we're just going to say
9:20local function um operation it could
9:24just be anything really it doesn't
9:25really matter uh and then we're going to
9:27pass in a word like this um we're going
9:31to hit enter like this and then what we
9:33can do here is basically return a new
9:35string by taking in the word and then we
9:37can concatenate this with let's say
9:39something random we can just say word uh
9:43I I don't know plus one I'm just like
9:46thinking of something random off the top
9:47of my head right now so we're going to
9:49have the word uh followed by a space and
9:51then in parenthesis plus one so we're
9:53just going to return that as the new
9:55string every single time we pass in a
9:57new word into this function so for our
10:00replacement instead of using a table
10:01we're going to just simply put in the
10:04operation function and the rest should
10:06do it for us so now let's hit run and
10:09then see our output like so uh we should
10:12see Hello plus one uh world plus one and
10:15then world plus one again so that is
10:18another cool thing you can do with G sub
10:19and I hope this part has um been very
10:22practical to you so far the next one is
10:24split and it's actually pretty easy if
10:26we imagined our string to be like this
10:29spaced out by three different words but
10:30we wanted to separate all of these words
10:33into an an array or in into a table that
10:37we can use to iterate through all of
10:39these different words what we can do is
10:42use the split function that basically
10:44splits this string into three different
10:48words inside of a table and then we can
10:50use that table to iterate through all
10:52the words so this is basically what it's
10:53going to look like we're just simply
10:55going to say local words because we're
10:57going to return a table equals
10:59string dosit open and close parenthesis
11:02we're first going to pass in the string
11:05and then we're going to pass in a
11:07separator and this can also be a string
11:08as well or just a simple character so in
11:11this case what we want to separate here
11:13is the space and so this separator is
11:16going to tell us that every anytime we
11:18see a space we're going to separate
11:20whatever was before it into a um entry
11:24and then we're going to put that into
11:25the table words like that it's kind of
11:27strange by default I'm pretty sure
11:29Roblox has commas as the separator even
11:33though in a lot of other languages they
11:35have space as the default so uh if
11:38you're trying to use space then you need
11:40to specify space if you want to uh
11:42separate the words so now that we have
11:45this we can basically iterate through uh
11:47every single word that's in the words
11:50table like this and then that's
11:54basically that's that's basically all we
11:56need to do right here so if we hit run
11:57then what we should see is is that for
11:59each entry it's going to print out all
12:01the words that have been separated so we
12:02have hello and then drops down a line to
12:05world and then finally world again after
12:07it was separated the next two functions
12:09are synonymous with each other and those
12:11are upper and lower so basically what
12:16these two functions do is it takes a
12:18string and then it takes and then it
12:21changes every single character to be the
12:23uppercase or lowercase version of that
12:26character so if we were to basically
12:29print out uh string. uper in this case
12:33and then we pass in my string like this
12:36it's going to take every single
12:37character and make it uppercase by force
12:41and then we can basically do the same
12:42thing down here with uh string. lower
12:46like this and then if we go into the
12:47game and then hit run we should see in
12:49the output that with my string it's
12:52going to first print out the entire
12:54string in all uppercase and then for the
12:56lower it's going to print out every
12:59single character in the string in
13:00lowercase I think it's pretty
13:01self-explanatory I don't need to explain
13:03too much on this one the next function
13:05is format and this is actually one of
13:06the more difficult ones to understand
13:08and this is something I can make a whole
13:10video about but I'm not going to go too
13:12much into detail about it I'm just going
13:13to show you the basics of using string
13:15format and how it works so let's say we
13:18have our string up here with hello world
13:20and we wanted to reuse this string to
13:23have a specific format so that if we
13:25wanted to use the string for a future
13:27use case or or if we just wanted to use
13:29a string that's very organized with this
13:31format that we like to have it with then
13:34we use the string format function that
13:37allows us to do that one example of
13:39using string format is by uh specifying
13:42one word in here that we want to change
13:45based on where we uh based on when and
13:48where we use this in our code so instead
13:50of world let's say we wanted to replace
13:52this with um braw Dev or we wanted to
13:56replace this in a different place with
13:59Roblox like we want to constantly we
14:01want to replace whatever this word is
14:04with a different word but using the same
14:06format what we can do is replace this
14:09with a specifier and the type of
14:11whatever this is inside of here so this
14:13is basically what it would look like so
14:15since we don't know what this is yet um
14:17we can now specify this with braw Dev we
14:20can even specify this with world and we
14:22can even specify this with roblocks
14:24depending on how we use this and this is
14:25basically how it works down here we can
14:27say print string
14:29format open close parenthesis pass in
14:31the string and then inside of here we
14:34can pass in whatever we want to replace
14:35this with we can basically say world and
14:38we can copy and paste this down here and
14:40we can replace this with brev and we can
14:42also replace this with roadblocks so if
14:45we hit run then we should see all three
14:48use cases down in the output so we
14:50should first see world then braev and
14:52then Roblox so that is one way we can
14:55use string format and there's definitely
14:56many other ways we can use this we can
14:58use this to help uh pad our strings to
15:01make it look nice by let's say having
15:03some padded uh space before or after a
15:05string using Flags uh we can even use um
15:10width to specify how long we want a
15:12specific um part in the string to be
15:15like let's say we had the number 100 but
15:18we wanted it to be longer than 100 for
15:21padding reasons like if we want to have
15:23multiple numbers that had a similar
15:25padding with two zeros regardless of how
15:28big or small numbers then we can just
15:30add some trailing zeros to here um if we
15:32wanted to give a certain amount of width
15:36to uh our formatted string like so
15:38there's a lot of use cases for this but
15:40I do want you to be aware of the four
15:43parts that make up a format it's the
15:45specifier which is indicated by this um
15:48percentage symbol right here then it's
15:50going to be the flags the width and then
15:52the Precision so the specifier
15:54essentially is this symbol right here
15:56like I just mentioned and whatever hap
15:58and and then whatever character we place
16:00after that that's going to specify the
16:03type of whatever we we want to insert
16:05inside of here so the S stands for
16:07string but if we wanted to let's say
16:09specify an integer or a number then we
16:11specify it using d uh or even I in this
16:14case if we wanted to do a float we would
16:16specify with f and you kind of get the
16:17idea with this specifier and this uh
16:20data type we can basically replace it
16:22with uh whatever this second argument is
16:24going to be right here so this float
16:26could be 10.5 and it's going to be put
16:29inside of here and you have to make sure
16:31that you get the right specifier type
16:33with whatever argument you're trying to
16:35put inside of these parameters right
16:37here Flags help us achieve uh certain
16:40kinds of uh formatting like let's say we
16:42wanted to add padding to the left side
16:44then what we can do is basically say uh
16:47let's say we had a print statement down
16:48here with string.format like this and
16:51then let's create our own pattern here
16:53if we wanted to let's say specify a flag
16:56of having a bunch of padded space on the
16:59right side of whatever we put inside of
17:01here then what we need to do is put down
17:03a negative sign and then we put down the
17:06the amount of padding we want to put in
17:08here so if we let's say wanted 10
17:10characters after we put in a value
17:12inside of here so this is going to be
17:14the padding and then whatever we specify
17:16inside of here we can let's say this be
17:18a number then we can put on the right
17:21side our number which in this case we
17:23could probably just say 100 I'm just
17:25going to comment these two parts out
17:26really quick okay so let me hit run very
17:28quick ly and then what we should see in
17:29the output is 100 but you might notice
17:32that there's all of this white space
17:34after it because we added a padding to
17:37it and what's interesting about this as
17:39well is we can combine multiple Flags
17:42together like another instance of this
17:43would be adding zeros to our padding so
17:47we could get rid of this negative flag
17:49and instead put a zero to Pad 10 zeros
17:54to the left of the number that we have
17:56specified here so if we hit run and then
17:58what we should see in the bottom is that
18:00there isn't exactly 10 zeros to the left
18:03of it but it has a fixed length of 10 uh
18:07numbers now because uh 100 makes up
18:09three of them and then the seven zeros
18:11pad the rest of them to the left side of
18:14the number and then we have things like
18:15Precision if let's say we had a decimal
18:18that we wanted to be in the hundreds or
18:20the thousands place like this um or if
18:23we want to have a period specifically
18:25after the 10 right here then what we can
18:28do is use uh what we can do is use float
18:31Point Precision which basically looks
18:33like this if we had a print statement
18:35with string. format like this um and
18:38then we basically had our own formatted
18:40string like this with a specifier and
18:43then a DOT uh let's say we want to have
18:46a number like this to F and then we
18:50specify the number we have right over
18:52here to the left side so let's say we
18:53want it to be 100 essentially What's
18:56Happening Here is we first have our
18:57specifier and then we have a period two
19:00which basically tells us that uh with
19:02whatever float value that we put inside
19:05of here uh we want to pad it with a DOT
19:09and then Pat it with two zeros after we
19:13give this number to this format so if we
19:15hit run then we should see in the output
19:17it shows
19:19100. because we specified a float Point
19:22Precision with the dot and the tube with
19:24also the f um afterwards as well so
19:27that's another and useful thing you can
19:29do with string format once again this is
19:31just a very brief overview of string
19:33format but I hope this gave you more
19:35insight into using string format for the
19:37future the next function is match now
19:40this is very similar to find that we had
19:43at the very beginning of this episode so
19:45this one right here because find
19:47returned two numbers that basically gave
19:49us the starting index and the ending
19:51index of where they found this matching
19:53pattern but this time this is just
19:55simply going to return the the value
19:58itself if it does find it in the string
20:01so this is all we're going to say we're
20:02just going to make a print statement
20:04right here and then we're just going to
20:05Simply say string. match open and close
20:08parentheses we're first going to put in
20:09my string and then whatever is going to
20:11be on the right side is going to be uh a
20:13string pattern so if let's say we wanted
20:15to find World in hello world then what
20:18it's simply just going to do is return
20:21that word that pattern that it found in
20:25the string so if we hit run then what we
20:27should see in the output is just simply
20:29world because it found world now if
20:33let's say we put something that it
20:34wouldn't be able to find like let's say
20:36the number uh 103 as a string then it
20:39should just print out nil because it was
20:43not able to find it so match basically
20:45says it either finds the word that it's
20:47looking for or it just returns nil and
20:49it's just as simple as that next up we
20:51have reverse which basically just takes
20:53the string and then it and then it flips
20:57the ordering of the uh characters in
21:00Reverse so if we were to print this out
21:03say string. reverse and then we pass in
21:06just one argument which is just going to
21:08be the string then all that's going to
21:10happen in the output is it's going to
21:12print out the same string but in the
21:15opposite direction so it's going to
21:18basically just say so it's basically
21:20just going to print hello world in
21:21Reverse it's pretty self-explanatory it
21:23shouldn't be that hard to understand I
21:24think you get it next function is rep
21:26and this is short for repeat so
21:29basically this takes the string and then
21:31it repeats that string over and over
21:33again uh for however many times we
21:35specify it with this function so this is
21:38basically what it's going to look like
21:39if we say print open and close
21:41parentheses string. rep open and close
21:44parentheses and then we p and then we
21:46first pass in my string and then at and
21:49then for the second argument we put down
21:51a number here so we can say three in
21:53this case it's going to print hello
21:55world or no the string is going to to
21:58say hello world hello world and then
22:00hello world three times so if we run the
22:02game and the output the one string
22:04should just say hello world hello world
22:07and then hello world so it just simply
22:08repeats the string that we pass in with
22:11however many times we specify on the
22:13right side the last function I'm going
22:14to introduce is g match which is short
22:17for Global match and it's as the name
22:19suggests it's pretty similar to match
22:21and how if we found a specific string or
22:24even a specific pattern within a bigger
22:27string then we would just simply return
22:30that string itself but with gmch what
22:32this does is it returns an iterator for
22:35us to constantly Loop through a uh big
22:38string to uh return uh the results of
22:41what we're trying to look for within
22:42that string it's especially useful if we
22:45provide a formatted string as the
22:48pattern and so here's what we can do we
22:50can essentially write a for Loop that
22:53can Loop through all of the words inside
22:55of the string and then we can print it
22:57out into the output just as a very basic
22:59example so here's what we're going to
23:00say we're going to say for word in
23:04string. g match and then in parentheses
23:08we're going to pass in our string and
23:10then our pattern which this is going to
23:12be a specifier for any word that we find
23:16inside of here so we're going to use the
23:19percentage sign W and then we're also
23:21going to add a plus flag to it so that
23:24um we know that we're we can retrieve
23:26any word that's past this so um once we
23:30do that we can say do and then we can
23:32simply just say print word and this is a
23:34very basic example of using gmch so if
23:37we hit run then what we should see in
23:38the output is simply just hello world
23:42without taking into account the um ex
23:45exclamation point at the very end of it
23:47because we're trying to catch words
23:48rather than symbols and with that being
23:51said that should be the 10 most used
23:53string functions that the string
23:55functions library has to offer I hope
23:56you found this video to be inform ative
23:58so with that being said I hope you
23:59understand more about using string
24:01functions inside of Roblox Studio I'll
24:03leave a link to the documentation in the
24:05description of this video if you want to
24:06take a closer look at it I might make a
24:08future video on string format as its own
24:11separate video because it is pretty
24:13confusing to learn about at first I
24:15encourage you to use these string
24:16functions in your Roblox scripts in in
24:19case you do want to mess around with
24:21strings because that is something you
24:23are pretty much going to have to do for
24:25a lot of the time you are going to be
24:26developing on Roblox so I hope this
24:28video serves you well if you want to
24:30learn more libraries that Roblox has to
24:32offer that I've covered on this channel
24:34I encourage you to watch my cortines
24:36video that I will have a link for you
24:38right here to watch but with that being
24:40said I hope you found this video to be
24:42helpful and I will see you in the next
24:44episode take care

About this transcript

This page contains the full transcript of String Functions (format, gsub, split, etc.) - Roblox Advanced Scripting #23 by BrawlDev, generated from the public captions YouTube serves with the video. The transcript has 4,969 words across 643 segments, with the original timestamps preserved so you can click any line to jump to that moment in the embedded player.

What you can do with it

Use the transcript to take notes, quote the speaker, build a study guide, generate a summary with ChatGPT or Claude via the YouTube Summary tool, or export it as a timed subtitle file with YouTube to SRT. You can also re-open it in the transcriber to choose a caption track available on the video.

Free YouTube transcript tool

YouTube2Text is a free YouTube transcript generator — no signup, no daily limit. Paste any YouTube link and get the full transcript instantly, with timestamps, click-to-jump, caption language selection, AI prompts for ChatGPT, Claude, and Gemini, and exports to TXT, SRT, VTT, or Markdown.